//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.activiti.engine.impl.cfg;

import com.fasterxml.jackson.annotation.JsonTypeInfo.Id;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.ServiceLoader;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.naming.InitialContext;
import javax.sql.DataSource;
import javax.xml.namespace.QName;
import org.activiti.api.runtime.shared.identity.UserGroupManager;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.DynamicBpmnService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.ManagementService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.cfg.ProcessEngineConfigurator;
import org.activiti.engine.delegate.event.ActivitiEventDispatcher;
import org.activiti.engine.delegate.event.ActivitiEventListener;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventDispatcherImpl;
import org.activiti.engine.impl.DynamicBpmnServiceImpl;
import org.activiti.engine.impl.HistoryServiceImpl;
import org.activiti.engine.impl.ManagementServiceImpl;
import org.activiti.engine.impl.ProcessEngineImpl;
import org.activiti.engine.impl.RepositoryServiceImpl;
import org.activiti.engine.impl.RuntimeServiceImpl;
import org.activiti.engine.impl.ServiceImpl;
import org.activiti.engine.impl.TaskServiceImpl;
import org.activiti.engine.impl.agenda.DefaultActivitiEngineAgendaFactory;
import org.activiti.engine.impl.asyncexecutor.DefaultAsyncJobExecutor;
import org.activiti.engine.impl.asyncexecutor.DefaultJobManager;
import org.activiti.engine.impl.asyncexecutor.ExecuteAsyncRunnableFactory;
import org.activiti.engine.impl.asyncexecutor.JobManager;
import org.activiti.engine.impl.bpmn.data.ItemInstance;
import org.activiti.engine.impl.bpmn.deployer.BpmnDeployer;
import org.activiti.engine.impl.bpmn.deployer.BpmnDeploymentHelper;
import org.activiti.engine.impl.bpmn.deployer.CachingAndArtifactsManager;
import org.activiti.engine.impl.bpmn.deployer.EventSubscriptionManager;
import org.activiti.engine.impl.bpmn.deployer.ParsedDeploymentBuilderFactory;
import org.activiti.engine.impl.bpmn.deployer.TimerManager;
import org.activiti.engine.impl.bpmn.listener.ListenerNotificationHelper;
import org.activiti.engine.impl.bpmn.parser.BpmnParseHandlers;
import org.activiti.engine.impl.bpmn.parser.BpmnParser;
import org.activiti.engine.impl.bpmn.parser.factory.AbstractBehaviorFactory;
import org.activiti.engine.impl.bpmn.parser.factory.ActivityBehaviorFactory;
import org.activiti.engine.impl.bpmn.parser.factory.DefaultActivityBehaviorFactory;
import org.activiti.engine.impl.bpmn.parser.factory.DefaultListenerFactory;
import org.activiti.engine.impl.bpmn.parser.factory.ListenerFactory;
import org.activiti.engine.impl.bpmn.parser.handler.AdhocSubProcessParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.BoundaryEventParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.BusinessRuleParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.CallActivityParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.CancelEventDefinitionParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.CompensateEventDefinitionParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.EndEventParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.ErrorEventDefinitionParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.EventBasedGatewayParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.EventSubProcessParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.ExclusiveGatewayParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.InclusiveGatewayParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.IntermediateCatchEventParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.IntermediateThrowEventParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.ManualTaskParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.MessageEventDefinitionParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.ParallelGatewayParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.ProcessParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.ReceiveTaskParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.ScriptTaskParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.SendTaskParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.SequenceFlowParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.ServiceTaskParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.SignalEventDefinitionParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.StartEventParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.SubProcessParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.TaskParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.TimerEventDefinitionParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.TransactionParseHandler;
import org.activiti.engine.impl.bpmn.parser.handler.UserTaskParseHandler;
import org.activiti.engine.impl.bpmn.webservice.MessageInstance;
import org.activiti.engine.impl.calendar.BusinessCalendarManager;
import org.activiti.engine.impl.calendar.CycleBusinessCalendar;
import org.activiti.engine.impl.calendar.DueDateBusinessCalendar;
import org.activiti.engine.impl.calendar.DurationBusinessCalendar;
import org.activiti.engine.impl.calendar.MapBusinessCalendarManager;
import org.activiti.engine.impl.cfg.standalone.StandaloneMybatisTransactionContextFactory;
import org.activiti.engine.impl.cmd.ValidateExecutionRelatedEntityCountCfgCmd;
import org.activiti.engine.impl.db.DbIdGenerator;
import org.activiti.engine.impl.db.DbSqlSessionFactory;
import org.activiti.engine.impl.db.IbatisVariableTypeHandler;
import org.activiti.engine.impl.delegate.invocation.DefaultDelegateInterceptor;
import org.activiti.engine.impl.el.ExpressionManager;
import org.activiti.engine.impl.event.CompensationEventHandler;
import org.activiti.engine.impl.event.EventHandler;
import org.activiti.engine.impl.event.EventSubscriptionPayloadMappingProvider;
import org.activiti.engine.impl.event.MessageEventHandler;
import org.activiti.engine.impl.event.SignalEventHandler;
import org.activiti.engine.impl.event.logger.EventLogger;
//import org.activiti.engine.impl.history.DefaultHistoryManager;
import org.activiti.engine.impl.history.HistoryLevel;
import org.activiti.engine.impl.history.HistoryManager;
import org.activiti.engine.impl.history.MyDefaultHistoryManager;
import org.activiti.engine.impl.interceptor.CommandConfig;
import org.activiti.engine.impl.interceptor.CommandContextFactory;
import org.activiti.engine.impl.interceptor.CommandContextInterceptor;
import org.activiti.engine.impl.interceptor.CommandExecutor;
import org.activiti.engine.impl.interceptor.CommandInterceptor;
import org.activiti.engine.impl.interceptor.CommandInvoker;
import org.activiti.engine.impl.interceptor.DebugCommandInvoker;
import org.activiti.engine.impl.interceptor.DelegateInterceptor;
import org.activiti.engine.impl.interceptor.LogInterceptor;
import org.activiti.engine.impl.interceptor.SessionFactory;
import org.activiti.engine.impl.interceptor.TransactionContextInterceptor;
import org.activiti.engine.impl.jobexecutor.AsyncContinuationJobHandler;
import org.activiti.engine.impl.jobexecutor.DefaultFailedJobCommandFactory;
import org.activiti.engine.impl.jobexecutor.FailedJobCommandFactory;
import org.activiti.engine.impl.jobexecutor.JobHandler;
import org.activiti.engine.impl.jobexecutor.ProcessEventJobHandler;
import org.activiti.engine.impl.jobexecutor.TimerActivateProcessDefinitionHandler;
import org.activiti.engine.impl.jobexecutor.TimerStartEventJobHandler;
import org.activiti.engine.impl.jobexecutor.TimerSuspendProcessDefinitionHandler;
import org.activiti.engine.impl.jobexecutor.TriggerTimerEventJobHandler;
import org.activiti.engine.impl.persistence.GenericManagerFactory;
import org.activiti.engine.impl.persistence.cache.EntityCache;
import org.activiti.engine.impl.persistence.cache.EntityCacheImpl;
import org.activiti.engine.impl.persistence.deploy.DefaultDeploymentCache;
import org.activiti.engine.impl.persistence.deploy.Deployer;
import org.activiti.engine.impl.persistence.deploy.DeploymentCache;
import org.activiti.engine.impl.persistence.deploy.DeploymentManager;
import org.activiti.engine.impl.persistence.deploy.ProcessDefinitionCacheEntry;
import org.activiti.engine.impl.persistence.deploy.ProcessDefinitionInfoCache;
import org.activiti.engine.impl.persistence.entity.AttachmentEntityManager;
import org.activiti.engine.impl.persistence.entity.AttachmentEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.ByteArrayEntityManager;
import org.activiti.engine.impl.persistence.entity.ByteArrayEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.CommentEntityManager;
import org.activiti.engine.impl.persistence.entity.CommentEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.DeadLetterJobEntityManager;
import org.activiti.engine.impl.persistence.entity.DeadLetterJobEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.DeploymentEntityManager;
import org.activiti.engine.impl.persistence.entity.DeploymentEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.EventLogEntryEntityManager;
import org.activiti.engine.impl.persistence.entity.EventLogEntryEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.EventSubscriptionEntityManager;
import org.activiti.engine.impl.persistence.entity.EventSubscriptionEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.ExecutionEntityManager;
import org.activiti.engine.impl.persistence.entity.ExecutionEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.HistoricActivityInstanceEntityManager;
import org.activiti.engine.impl.persistence.entity.HistoricActivityInstanceEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.HistoricDetailEntityManager;
import org.activiti.engine.impl.persistence.entity.HistoricDetailEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.HistoricIdentityLinkEntityManager;
import org.activiti.engine.impl.persistence.entity.HistoricIdentityLinkEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.HistoricProcessInstanceEntityManager;
import org.activiti.engine.impl.persistence.entity.HistoricProcessInstanceEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.HistoricTaskInstanceEntityManager;
import org.activiti.engine.impl.persistence.entity.HistoricTaskInstanceEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.HistoricVariableInstanceEntityManager;
import org.activiti.engine.impl.persistence.entity.HistoricVariableInstanceEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.IdentityLinkEntityManager;
import org.activiti.engine.impl.persistence.entity.IdentityLinkEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.JobEntityManager;
import org.activiti.engine.impl.persistence.entity.JobEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.ModelEntityManager;
import org.activiti.engine.impl.persistence.entity.ModelEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntityManager;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionInfoEntityManager;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionInfoEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.PropertyEntityManager;
import org.activiti.engine.impl.persistence.entity.PropertyEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.ResourceEntityManager;
import org.activiti.engine.impl.persistence.entity.ResourceEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.SuspendedJobEntityManager;
import org.activiti.engine.impl.persistence.entity.SuspendedJobEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.TableDataManager;
import org.activiti.engine.impl.persistence.entity.TableDataManagerImpl;
import org.activiti.engine.impl.persistence.entity.TaskEntityManager;
import org.activiti.engine.impl.persistence.entity.TaskEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.TimerJobEntityManager;
import org.activiti.engine.impl.persistence.entity.TimerJobEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.VariableInstanceEntityManager;
import org.activiti.engine.impl.persistence.entity.VariableInstanceEntityManagerImpl;
import org.activiti.engine.impl.persistence.entity.data.AttachmentDataManager;
import org.activiti.engine.impl.persistence.entity.data.ByteArrayDataManager;
import org.activiti.engine.impl.persistence.entity.data.CommentDataManager;
import org.activiti.engine.impl.persistence.entity.data.DeadLetterJobDataManager;
import org.activiti.engine.impl.persistence.entity.data.DeploymentDataManager;
import org.activiti.engine.impl.persistence.entity.data.EventLogEntryDataManager;
import org.activiti.engine.impl.persistence.entity.data.EventSubscriptionDataManager;
import org.activiti.engine.impl.persistence.entity.data.ExecutionDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricActivityInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricDetailDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricIdentityLinkDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricProcessInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricTaskInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.HistoricVariableInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.IdentityLinkDataManager;
import org.activiti.engine.impl.persistence.entity.data.JobDataManager;
import org.activiti.engine.impl.persistence.entity.data.ModelDataManager;
import org.activiti.engine.impl.persistence.entity.data.ProcessDefinitionDataManager;
import org.activiti.engine.impl.persistence.entity.data.ProcessDefinitionInfoDataManager;
import org.activiti.engine.impl.persistence.entity.data.PropertyDataManager;
import org.activiti.engine.impl.persistence.entity.data.ResourceDataManager;
import org.activiti.engine.impl.persistence.entity.data.SuspendedJobDataManager;
import org.activiti.engine.impl.persistence.entity.data.TaskDataManager;
import org.activiti.engine.impl.persistence.entity.data.TimerJobDataManager;
import org.activiti.engine.impl.persistence.entity.data.VariableInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisAttachmentDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisByteArrayDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisCommentDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisDeadLetterJobDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisDeploymentDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisEventLogEntryDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisEventSubscriptionDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisExecutionDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisHistoricActivityInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisHistoricDetailDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisHistoricIdentityLinkDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisHistoricProcessInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisHistoricTaskInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisHistoricVariableInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisIdentityLinkDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisJobDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisModelDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisProcessDefinitionDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisProcessDefinitionInfoDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisPropertyDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisResourceDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisSuspendedJobDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisTaskDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisTimerJobDataManager;
import org.activiti.engine.impl.persistence.entity.data.impl.MybatisVariableInstanceDataManager;
import org.activiti.engine.impl.persistence.entity.data.integration.IntegrationContextDataManager;
import org.activiti.engine.impl.persistence.entity.data.integration.MybatisIntegrationContextDataManager;
import org.activiti.engine.impl.persistence.entity.integration.IntegrationContextManager;
import org.activiti.engine.impl.persistence.entity.integration.IntegrationContextManagerImpl;
import org.activiti.engine.impl.scripting.BeansResolverFactory;
import org.activiti.engine.impl.scripting.ResolverFactory;
import org.activiti.engine.impl.scripting.ScriptBindingsFactory;
import org.activiti.engine.impl.scripting.ScriptingEngines;
import org.activiti.engine.impl.scripting.VariableScopeResolverFactory;
import org.activiti.engine.impl.util.DefaultClockImpl;
import org.activiti.engine.impl.util.IoUtil;
import org.activiti.engine.impl.util.ProcessInstanceHelper;
import org.activiti.engine.impl.util.ReflectUtil;
import org.activiti.engine.impl.variable.BooleanType;
import org.activiti.engine.impl.variable.ByteArrayType;
import org.activiti.engine.impl.variable.CustomObjectType;
import org.activiti.engine.impl.variable.DateType;
import org.activiti.engine.impl.variable.DefaultVariableTypes;
import org.activiti.engine.impl.variable.DoubleType;
import org.activiti.engine.impl.variable.EntityManagerSession;
import org.activiti.engine.impl.variable.EntityManagerSessionFactory;
import org.activiti.engine.impl.variable.IntegerType;
import org.activiti.engine.impl.variable.JPAEntityListVariableType;
import org.activiti.engine.impl.variable.JPAEntityVariableType;
import org.activiti.engine.impl.variable.JodaDateTimeType;
import org.activiti.engine.impl.variable.JodaDateType;
import org.activiti.engine.impl.variable.JsonType;
import org.activiti.engine.impl.variable.JsonTypeConverter;
import org.activiti.engine.impl.variable.LongJsonType;
import org.activiti.engine.impl.variable.LongStringType;
import org.activiti.engine.impl.variable.LongType;
import org.activiti.engine.impl.variable.NullType;
import org.activiti.engine.impl.variable.SerializableType;
import org.activiti.engine.impl.variable.ShortType;
import org.activiti.engine.impl.variable.StringType;
import org.activiti.engine.impl.variable.UUIDType;
import org.activiti.engine.impl.variable.VariableType;
import org.activiti.engine.impl.variable.VariableTypes;
import org.activiti.engine.integration.IntegrationContextService;
import org.activiti.engine.integration.IntegrationContextServiceImpl;
import org.activiti.engine.parse.BpmnParseHandler;
import org.activiti.engine.runtime.Clock;
import org.activiti.validation.ProcessValidator;
import org.activiti.validation.ProcessValidatorFactory;
import org.apache.ibatis.builder.xml.XMLConfigBuilder;
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.datasource.pooled.PooledDataSource;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.defaults.DefaultSqlSessionFactory;
import org.apache.ibatis.transaction.TransactionFactory;
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
import org.apache.ibatis.transaction.managed.ManagedTransactionFactory;
import org.apache.ibatis.type.JdbcType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * 
 *  ACT 的引擎管理器
 *    获得ACT的manager
 */

public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfiguration {
  private static Logger log = LoggerFactory.getLogger(ProcessEngineConfigurationImpl.class);
  public static final String DB_SCHEMA_UPDATE_CREATE = "create";
  public static final String DB_SCHEMA_UPDATE_DROP_CREATE = "drop-create";
  public static final String DEFAULT_WS_SYNC_FACTORY = "org.activiti.engine.impl.webservice.CxfWebServiceClientFactory";
  public static final String DEFAULT_MYBATIS_MAPPING_FILE = "org/activiti/db/mapping/mappings.xml";
  public static final int DEFAULT_GENERIC_MAX_LENGTH_STRING = 4000;
  public static final int DEFAULT_ORACLE_MAX_LENGTH_STRING = 2000;
  protected RepositoryService repositoryService = new RepositoryServiceImpl();
  protected RuntimeService runtimeService = new RuntimeServiceImpl();
  protected HistoryService historyService = new HistoryServiceImpl(this);
  protected TaskService taskService = new TaskServiceImpl(this);
  protected ManagementService managementService = new ManagementServiceImpl();
  protected DynamicBpmnService dynamicBpmnService = new DynamicBpmnServiceImpl(this);
  protected UserGroupManager userGroupManager;
  private IntegrationContextService integrationContextService;
  protected CommandConfig defaultCommandConfig;
  protected CommandConfig schemaCommandConfig;
  protected CommandInterceptor commandInvoker;
  protected List<CommandInterceptor> customPreCommandInterceptors;
  protected List<CommandInterceptor> customPostCommandInterceptors;
  protected List<CommandInterceptor> commandInterceptors;
  protected CommandExecutor commandExecutor;
  protected AttachmentDataManager attachmentDataManager;
  protected ByteArrayDataManager byteArrayDataManager;
  protected CommentDataManager commentDataManager;
  protected DeploymentDataManager deploymentDataManager;
  protected EventLogEntryDataManager eventLogEntryDataManager;
  protected EventSubscriptionDataManager eventSubscriptionDataManager;
  protected ExecutionDataManager executionDataManager;
  protected HistoricActivityInstanceDataManager historicActivityInstanceDataManager;
  protected HistoricDetailDataManager historicDetailDataManager;
  protected HistoricIdentityLinkDataManager historicIdentityLinkDataManager;
  protected HistoricProcessInstanceDataManager historicProcessInstanceDataManager;
  protected HistoricTaskInstanceDataManager historicTaskInstanceDataManager;
  protected HistoricVariableInstanceDataManager historicVariableInstanceDataManager;
  protected IdentityLinkDataManager identityLinkDataManager;
  protected JobDataManager jobDataManager;
  protected TimerJobDataManager timerJobDataManager;
  protected SuspendedJobDataManager suspendedJobDataManager;
  protected DeadLetterJobDataManager deadLetterJobDataManager;
  protected ModelDataManager modelDataManager;
  protected ProcessDefinitionDataManager processDefinitionDataManager;
  protected ProcessDefinitionInfoDataManager processDefinitionInfoDataManager;
  protected PropertyDataManager propertyDataManager;
  protected ResourceDataManager resourceDataManager;
  protected TaskDataManager taskDataManager;
  protected VariableInstanceDataManager variableInstanceDataManager;
  private IntegrationContextDataManager integrationContextDataManager;
  protected AttachmentEntityManager attachmentEntityManager;
  protected ByteArrayEntityManager byteArrayEntityManager;
  protected CommentEntityManager commentEntityManager;
  protected DeploymentEntityManager deploymentEntityManager;
  protected EventLogEntryEntityManager eventLogEntryEntityManager;
  protected EventSubscriptionEntityManager eventSubscriptionEntityManager;
  protected ExecutionEntityManager executionEntityManager;
  protected HistoricActivityInstanceEntityManager historicActivityInstanceEntityManager;
  protected HistoricDetailEntityManager historicDetailEntityManager;
  protected HistoricIdentityLinkEntityManager historicIdentityLinkEntityManager;
  protected HistoricProcessInstanceEntityManager historicProcessInstanceEntityManager;
  protected HistoricTaskInstanceEntityManager historicTaskInstanceEntityManager;
  protected HistoricVariableInstanceEntityManager historicVariableInstanceEntityManager;
  protected IdentityLinkEntityManager identityLinkEntityManager;
  protected JobEntityManager jobEntityManager;
  protected TimerJobEntityManager timerJobEntityManager;
  protected SuspendedJobEntityManager suspendedJobEntityManager;
  protected DeadLetterJobEntityManager deadLetterJobEntityManager;
  protected ModelEntityManager modelEntityManager;
  protected ProcessDefinitionEntityManager processDefinitionEntityManager;
  protected ProcessDefinitionInfoEntityManager processDefinitionInfoEntityManager;
  protected PropertyEntityManager propertyEntityManager;
  protected ResourceEntityManager resourceEntityManager;
  protected TableDataManager tableDataManager;
  protected TaskEntityManager taskEntityManager;
  protected VariableInstanceEntityManager variableInstanceEntityManager;
  private IntegrationContextManager integrationContextManager;
  private EventSubscriptionPayloadMappingProvider eventSubscriptionPayloadMappingProvider = new EventSubscriptionPayloadMappingProvider() {
  };
  protected HistoryManager historyManager;
  protected JobManager jobManager;
  protected List<SessionFactory> customSessionFactories;
  protected DbSqlSessionFactory dbSqlSessionFactory;
  protected Map<Class<?>, SessionFactory> sessionFactories;
  protected boolean enableConfiguratorServiceLoader = true;
  protected List<ProcessEngineConfigurator> configurators;
  protected List<ProcessEngineConfigurator> allConfigurators;
  protected BpmnDeployer bpmnDeployer;
  protected BpmnParser bpmnParser;
  protected ParsedDeploymentBuilderFactory parsedDeploymentBuilderFactory;
  protected TimerManager timerManager;
  protected EventSubscriptionManager eventSubscriptionManager;
  protected BpmnDeploymentHelper bpmnDeploymentHelper;
  protected CachingAndArtifactsManager cachingAndArtifactsManager;
  protected List<Deployer> customPreDeployers;
  protected List<Deployer> customPostDeployers;
  protected List<Deployer> deployers;
  protected DeploymentManager deploymentManager;
  protected int processDefinitionCacheLimit = -1;
  protected DeploymentCache<ProcessDefinitionCacheEntry> processDefinitionCache;
  protected int processDefinitionInfoCacheLimit = -1;
  protected ProcessDefinitionInfoCache processDefinitionInfoCache;
  protected int knowledgeBaseCacheLimit = -1;
  protected DeploymentCache<Object> knowledgeBaseCache;
  protected List<JobHandler> customJobHandlers;
  protected Map<String, JobHandler> jobHandlers;
  protected ProcessInstanceHelper processInstanceHelper;
  protected ListenerNotificationHelper listenerNotificationHelper;
  protected int asyncExecutorNumberOfRetries = 3;
  protected int asyncExecutorCorePoolSize = 2;
  protected int asyncExecutorMaxPoolSize = 10;
  protected long asyncExecutorThreadKeepAliveTime = 5000L;
  protected int asyncExecutorThreadPoolQueueSize = 100;
  protected BlockingQueue<Runnable> asyncExecutorThreadPoolQueue;
  protected long asyncExecutorSecondsToWaitOnShutdown = 60L;
  protected int asyncExecutorMaxTimerJobsPerAcquisition = 1;
  protected int asyncExecutorMaxAsyncJobsDuePerAcquisition = 1;
  protected int asyncExecutorDefaultTimerJobAcquireWaitTime = 10000;
  protected int asyncExecutorDefaultAsyncJobAcquireWaitTime = 10000;
  protected int asyncExecutorDefaultQueueSizeFullWaitTime = 0;
  protected String asyncExecutorLockOwner;
  protected int asyncExecutorTimerLockTimeInMillis = 300000;
  protected int asyncExecutorAsyncJobLockTimeInMillis = 300000;
  protected int asyncExecutorResetExpiredJobsInterval = 60000;
  protected int asyncExecutorResetExpiredJobsPageSize = 3;
  protected boolean asyncExecutorMessageQueueMode;
  protected ExecuteAsyncRunnableFactory asyncExecutorExecuteAsyncRunnableFactory;
  protected SqlSessionFactory sqlSessionFactory;
  protected TransactionFactory transactionFactory;
  protected Set<Class<?>> customMybatisMappers;
  protected Set<String> customMybatisXMLMappers;
  protected IdGenerator idGenerator;
  protected DataSource idGeneratorDataSource;
  protected String idGeneratorDataSourceJndiName;
  protected List<BpmnParseHandler> preBpmnParseHandlers;
  protected List<BpmnParseHandler> postBpmnParseHandlers;
  protected List<BpmnParseHandler> customDefaultBpmnParseHandlers;
  protected ActivityBehaviorFactory activityBehaviorFactory;
  protected ListenerFactory listenerFactory;
  protected BpmnParseFactory bpmnParseFactory;
  protected ProcessValidator processValidator;
  protected List<VariableType> customPreVariableTypes;
  protected List<VariableType> customPostVariableTypes;
  protected VariableTypes variableTypes;
  protected boolean serializableVariableTypeTrackDeserializedObjects = true;
  protected boolean serializePOJOsInVariablesToJson = false;
  protected String javaClassFieldForJackson;
  protected ExpressionManager expressionManager;
  protected List<String> customScriptingEngineClasses;
  protected ScriptingEngines scriptingEngines;
  protected List<ResolverFactory> resolverFactories;
  protected BusinessCalendarManager businessCalendarManager;
  protected int executionQueryLimit;
  protected int taskQueryLimit;
  protected int historicTaskQueryLimit;
  protected int historicProcessInstancesQueryLimit;
  protected String wsSyncFactoryClassName;
  protected ConcurrentMap<QName, URL> wsOverridenEndpointAddresses;
  protected CommandContextFactory commandContextFactory;
  protected TransactionContextFactory transactionContextFactory;
  protected Map<Object, Object> beans;
  protected DelegateInterceptor delegateInterceptor;
  protected Map<String, EventHandler> eventHandlers;
  protected List<EventHandler> customEventHandlers;
  protected FailedJobCommandFactory failedJobCommandFactory;
  protected boolean enableSafeBpmnXml;
  protected int batchSizeProcessInstances;
  protected int batchSizeTasks;
  protected boolean enableEventDispatcher;
  protected ActivitiEventDispatcher eventDispatcher;
  protected List<ActivitiEventListener> eventListeners;
  protected Map<String, List<ActivitiEventListener>> typedEventListeners;
  protected boolean enableDatabaseEventLogging;
  protected DelegateExpressionFieldInjectionMode delegateExpressionFieldInjectionMode;
  protected int maxLengthStringVariableType;
  protected boolean isBulkInsertEnabled;
  protected int maxNrOfStatementsInBulkInsert;
  public int DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER;
  protected ObjectMapper objectMapper;
  protected boolean usingRelationalDatabase;
  protected boolean enableVerboseExecutionTreeLogging;
  protected PerformanceSettings performanceSettings;
  protected static Properties databaseTypeMappings = getDefaultDatabaseTypeMappings();
  public static final String DATABASE_TYPE_H2 = "h2";
  public static final String DATABASE_TYPE_HSQL = "hsql";
  public static final String DATABASE_TYPE_MYSQL = "mysql";
  public static final String DATABASE_TYPE_ORACLE = "oracle";
  public static final String DATABASE_TYPE_POSTGRES = "postgres";
  public static final String DATABASE_TYPE_MSSQL = "mssql";
  public static final String DATABASE_TYPE_DB2 = "db2";

  public ProcessEngineConfigurationImpl() {
    this.javaClassFieldForJackson = Id.CLASS.getDefaultPropertyName();
    this.executionQueryLimit = 20000;
    this.taskQueryLimit = 20000;
    this.historicTaskQueryLimit = 20000;
    this.historicProcessInstancesQueryLimit = 20000;
    this.wsSyncFactoryClassName = "org.activiti.engine.impl.webservice.CxfWebServiceClientFactory";
    this.wsOverridenEndpointAddresses = new ConcurrentHashMap();
    this.batchSizeProcessInstances = 25;
    this.batchSizeTasks = 25;
    this.enableEventDispatcher = true;
    this.delegateExpressionFieldInjectionMode = DelegateExpressionFieldInjectionMode.MIXED;
    this.maxLengthStringVariableType = -1;
    this.isBulkInsertEnabled = true;
    this.maxNrOfStatementsInBulkInsert = 100;
    this.DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER = 70;
    this.objectMapper = new ObjectMapper();
    this.usingRelationalDatabase = true;
    this.performanceSettings = new PerformanceSettings();
  }

  public ProcessEngine buildProcessEngine() {
    this.init();
    ProcessEngineImpl processEngine = new ProcessEngineImpl(this);
    this.postProcessEngineInitialisation();
    return processEngine;
  }

  public void init() {
    this.initConfigurators();
    this.configuratorsBeforeInit();
    this.initHistoryLevel();
    this.initExpressionManager();
    if (this.usingRelationalDatabase) {
      this.initDataSource();
    }

    this.initAgendaFactory();
    this.initHelpers();
    this.initVariableTypes();
    this.initBeans();
    this.initScriptingEngines();
    this.initClock();
    this.initBusinessCalendarManager();
    this.initCommandContextFactory();
    this.initTransactionContextFactory();
    this.initCommandExecutors();
    this.initServices();
    this.initIdGenerator();
    this.initBehaviorFactory();
    this.initListenerFactory();
    this.initBpmnParser();
    this.initProcessDefinitionCache();
    this.initProcessDefinitionInfoCache();
    this.initKnowledgeBaseCache();
    this.initJobHandlers();
    this.initJobManager();
    this.initAsyncExecutor();
    this.initTransactionFactory();
    if (this.usingRelationalDatabase) {
      this.initSqlSessionFactory();
    }

    this.initSessionFactories();
    this.initDataManagers();
    this.initEntityManagers();
    this.initHistoryManager();
    this.initJpa();
    this.initDeployers();
    this.initDelegateInterceptor();
    this.initEventHandlers();
    this.initFailedJobCommandFactory();
    this.initEventDispatcher();
    this.initProcessValidator();
    this.initDatabaseEventLogging();
    this.configuratorsAfterInit();
  }

  public void initFailedJobCommandFactory() {
    if (this.failedJobCommandFactory == null) {
      this.failedJobCommandFactory = new DefaultFailedJobCommandFactory();
    }

  }

  public void initCommandExecutors() {
    this.initDefaultCommandConfig();
    this.initSchemaCommandConfig();
    this.initCommandInvoker();
    this.initCommandInterceptors();
    this.initCommandExecutor();
  }

  public void initDefaultCommandConfig() {
    if (this.defaultCommandConfig == null) {
      this.defaultCommandConfig = new CommandConfig();
    }

  }

  public void initSchemaCommandConfig() {
    if (this.schemaCommandConfig == null) {
      this.schemaCommandConfig = (new CommandConfig()).transactionNotSupported();
    }

  }

  public void initCommandInvoker() {
    if (this.commandInvoker == null) {
      if (this.enableVerboseExecutionTreeLogging) {
        this.commandInvoker = new DebugCommandInvoker();
      } else {
        this.commandInvoker = new CommandInvoker();
      }
    }

  }

  public void initCommandInterceptors() {
    if (this.commandInterceptors == null) {
      this.commandInterceptors = new ArrayList();
      if (this.customPreCommandInterceptors != null) {
        this.commandInterceptors.addAll(this.customPreCommandInterceptors);
      }

      this.commandInterceptors.addAll(this.getDefaultCommandInterceptors());
      if (this.customPostCommandInterceptors != null) {
        this.commandInterceptors.addAll(this.customPostCommandInterceptors);
      }

      this.commandInterceptors.add(this.commandInvoker);
    }

  }

  public Collection<? extends CommandInterceptor> getDefaultCommandInterceptors() {
    List<CommandInterceptor> interceptors = new ArrayList();
    interceptors.add(new LogInterceptor());
    CommandInterceptor transactionInterceptor = this.createTransactionInterceptor();
    if (transactionInterceptor != null) {
      interceptors.add(transactionInterceptor);
    }

    if (this.commandContextFactory != null) {
      interceptors.add(new CommandContextInterceptor(this.commandContextFactory, this));
    }

    if (this.transactionContextFactory != null) {
      interceptors.add(new TransactionContextInterceptor(this.transactionContextFactory));
    }

    return interceptors;
  }

  public void initCommandExecutor() {
    if (this.commandExecutor == null) {
      CommandInterceptor first = this.initInterceptorChain(this.commandInterceptors);
      this.commandExecutor = new CommandExecutorImpl(this.getDefaultCommandConfig(), first);
    }

  }

  public CommandInterceptor initInterceptorChain(List<CommandInterceptor> chain) {
    if (chain != null && !chain.isEmpty()) {
      for(int i = 0; i < chain.size() - 1; ++i) {
        ((CommandInterceptor)chain.get(i)).setNext((CommandInterceptor)chain.get(i + 1));
      }

      return (CommandInterceptor)chain.get(0);
    } else {
      throw new ActivitiException("invalid command interceptor chain configuration: " + chain);
    }
  }

  public abstract CommandInterceptor createTransactionInterceptor();

  public void initServices() {
    this.initService(this.repositoryService);
    this.initService(this.runtimeService);
    this.initService(this.historyService);
    this.initService(this.taskService);
    this.initService(this.managementService);
    this.initService(this.dynamicBpmnService);
  }

  public void initService(Object service) {
    if (service instanceof ServiceImpl) {
      ((ServiceImpl)service).setCommandExecutor(this.commandExecutor);
    }

  }

  public void initDataSource() {
    if (this.dataSource == null) {
      if (this.dataSourceJndiName != null) {
        try {
          this.dataSource = (DataSource)(new InitialContext()).lookup(this.dataSourceJndiName);
        } catch (Exception var2) {
          throw new ActivitiException("couldn't lookup datasource from " + this.dataSourceJndiName + ": " + var2.getMessage(), var2);
        }
      } else if (this.jdbcUrl != null) {
        if (this.jdbcDriver == null || this.jdbcUsername == null) {
          throw new ActivitiException("DataSource or JDBC properties have to be specified in a process engine configuration");
        }

        log.debug("initializing datasource to db: {}", this.jdbcUrl);
        PooledDataSource pooledDataSource = new PooledDataSource(ReflectUtil.getClassLoader(), this.jdbcDriver, this.jdbcUrl, this.jdbcUsername, this.jdbcPassword);
        if (this.jdbcMaxActiveConnections > 0) {
          pooledDataSource.setPoolMaximumActiveConnections(this.jdbcMaxActiveConnections);
        }

        if (this.jdbcMaxIdleConnections > 0) {
          pooledDataSource.setPoolMaximumIdleConnections(this.jdbcMaxIdleConnections);
        }

        if (this.jdbcMaxCheckoutTime > 0) {
          pooledDataSource.setPoolMaximumCheckoutTime(this.jdbcMaxCheckoutTime);
        }

        if (this.jdbcMaxWaitTime > 0) {
          pooledDataSource.setPoolTimeToWait(this.jdbcMaxWaitTime);
        }

        if (this.jdbcPingEnabled) {
          pooledDataSource.setPoolPingEnabled(true);
          if (this.jdbcPingQuery != null) {
            pooledDataSource.setPoolPingQuery(this.jdbcPingQuery);
          }

          pooledDataSource.setPoolPingConnectionsNotUsedFor(this.jdbcPingConnectionNotUsedFor);
        }

        if (this.jdbcDefaultTransactionIsolationLevel > 0) {
          pooledDataSource.setDefaultTransactionIsolationLevel(this.jdbcDefaultTransactionIsolationLevel);
        }

        this.dataSource = pooledDataSource;
      }

      if (this.dataSource instanceof PooledDataSource) {
        ((PooledDataSource)this.dataSource).forceCloseAll();
      }
    }

    if (this.databaseType == null) {
      this.initDatabaseType();
    }

  }

  public static Properties getDefaultDatabaseTypeMappings() {
    Properties databaseTypeMappings = new Properties();
    databaseTypeMappings.setProperty("H2", "h2");
    databaseTypeMappings.setProperty("HSQL Database Engine", "hsql");
    databaseTypeMappings.setProperty("MySQL", "mysql");
    databaseTypeMappings.setProperty("Oracle", "oracle");
    databaseTypeMappings.setProperty("PostgreSQL", "postgres");
    databaseTypeMappings.setProperty("Microsoft SQL Server", "mssql");
    databaseTypeMappings.setProperty("db2", "db2");
    databaseTypeMappings.setProperty("DB2", "db2");
    databaseTypeMappings.setProperty("DB2/NT", "db2");
    databaseTypeMappings.setProperty("DB2/NT64", "db2");
    databaseTypeMappings.setProperty("DB2 UDP", "db2");
    databaseTypeMappings.setProperty("DB2/LINUX", "db2");
    databaseTypeMappings.setProperty("DB2/LINUX390", "db2");
    databaseTypeMappings.setProperty("DB2/LINUXX8664", "db2");
    databaseTypeMappings.setProperty("DB2/LINUXZ64", "db2");
    databaseTypeMappings.setProperty("DB2/LINUXPPC64", "db2");
    databaseTypeMappings.setProperty("DB2/LINUXPPC64LE", "db2");
    databaseTypeMappings.setProperty("DB2/400 SQL", "db2");
    databaseTypeMappings.setProperty("DB2/6000", "db2");
    databaseTypeMappings.setProperty("DB2 UDB iSeries", "db2");
    databaseTypeMappings.setProperty("DB2/AIX64", "db2");
    databaseTypeMappings.setProperty("DB2/HPUX", "db2");
    databaseTypeMappings.setProperty("DB2/HP64", "db2");
    databaseTypeMappings.setProperty("DB2/SUN", "db2");
    databaseTypeMappings.setProperty("DB2/SUN64", "db2");
    databaseTypeMappings.setProperty("DB2/PTX", "db2");
    databaseTypeMappings.setProperty("DB2/2", "db2");
    databaseTypeMappings.setProperty("DB2 UDB AS400", "db2");
    return databaseTypeMappings;
  }

  public void initDatabaseType() {
    Connection connection = null;

    try {
      connection = this.dataSource.getConnection();
      DatabaseMetaData databaseMetaData = connection.getMetaData();
      String databaseProductName = databaseMetaData.getDatabaseProductName();
      log.debug("database product name: '{}'", databaseProductName);
      this.databaseType = databaseTypeMappings.getProperty(databaseProductName);
      if (this.databaseType == null) {
        throw new ActivitiException("couldn't deduct database type from database product name '" + databaseProductName + "'");
      }

      log.debug("using database type: {}", this.databaseType);
      if ("mssql".equals(this.databaseType)) {
        this.maxNrOfStatementsInBulkInsert = this.DEFAULT_MAX_NR_OF_STATEMENTS_BULK_INSERT_SQL_SERVER;
      }
    } catch (SQLException var12) {
      log.error("Exception while initializing Database connection", var12);
    } finally {
      try {
        if (connection != null) {
          connection.close();
        }
      } catch (SQLException var11) {
        log.error("Exception while closing the Database connection", var11);
      }

    }

  }

  public void initTransactionFactory() {
    if (this.transactionFactory == null) {
      if (this.transactionsExternallyManaged) {
        this.transactionFactory = new ManagedTransactionFactory();
      } else {
        this.transactionFactory = new JdbcTransactionFactory();
      }
    }

  }

  public void initSqlSessionFactory() {
    if (this.sqlSessionFactory == null) {
      InputStream inputStream = null;

      try {
        inputStream = this.getMyBatisXmlConfigurationStream();
        Environment environment = new Environment("default", this.transactionFactory, this.dataSource);
        Reader reader = new InputStreamReader(inputStream);
        Properties properties = new Properties();
        properties.put("prefix", this.databaseTablePrefix);
        String wildcardEscapeClause = "";
        if (this.databaseWildcardEscapeCharacter != null && this.databaseWildcardEscapeCharacter.length() != 0) {
          wildcardEscapeClause = " escape '" + this.databaseWildcardEscapeCharacter + "'";
        }

        properties.put("wildcardEscapeClause", wildcardEscapeClause);
        properties.put("limitBefore", "");
        properties.put("limitAfter", "");
        properties.put("limitBetween", "");
        properties.put("limitOuterJoinBetween", "");
        properties.put("limitBeforeNativeQuery", "");
        properties.put("orderBy", "order by ${orderByColumns}");
        properties.put("blobType", "BLOB");
        properties.put("boolValue", "TRUE");
        if (this.databaseType != null) {
          properties.load(this.getResourceAsStream("org/activiti/db/properties/" + this.databaseType + ".properties"));
        }

        Configuration configuration = this.initMybatisConfiguration(environment, reader, properties);
        this.sqlSessionFactory = new DefaultSqlSessionFactory(configuration);
      } catch (Exception var10) {
        throw new ActivitiException("Error while building ibatis SqlSessionFactory: " + var10.getMessage(), var10);
      } finally {
        IoUtil.closeSilently(inputStream);
      }
    }

  }

  public Configuration initMybatisConfiguration(Environment environment, Reader reader, Properties properties) {
    XMLConfigBuilder parser = new XMLConfigBuilder(reader, "", properties);
    Configuration configuration = parser.getConfiguration();
    if (this.databaseType != null) {
      configuration.setDatabaseId(this.databaseType);
    }

    configuration.setEnvironment(environment);
    this.initMybatisTypeHandlers(configuration);
    this.initCustomMybatisMappers(configuration);
    configuration = this.parseMybatisConfiguration(configuration, parser);
    return configuration;
  }

  public void initMybatisTypeHandlers(Configuration configuration) {
    configuration.getTypeHandlerRegistry().register(VariableType.class, JdbcType.VARCHAR, new IbatisVariableTypeHandler());
  }

  public void initCustomMybatisMappers(Configuration configuration) {
    if (this.getCustomMybatisMappers() != null) {
      Iterator var2 = this.getCustomMybatisMappers().iterator();

      while(var2.hasNext()) {
        Class<?> clazz = (Class)var2.next();
        configuration.addMapper(clazz);
      }
    }

  }

  public Configuration parseMybatisConfiguration(Configuration configuration, XMLConfigBuilder parser) {
    return this.parseCustomMybatisXMLMappers(parser.parse());
  }

  public Configuration parseCustomMybatisXMLMappers(Configuration configuration) {
    if (this.getCustomMybatisXMLMappers() != null) {
      Iterator var2 = this.getCustomMybatisXMLMappers().iterator();

      while(var2.hasNext()) {
        String resource = (String)var2.next();
        XMLMapperBuilder mapperParser = new XMLMapperBuilder(this.getResourceAsStream(resource), configuration, resource, configuration.getSqlFragments());
        mapperParser.parse();
      }
    }

    return configuration;
  }

  protected InputStream getResourceAsStream(String resource) {
    return ReflectUtil.getResourceAsStream(resource);
  }

  public InputStream getMyBatisXmlConfigurationStream() {
    return this.getResourceAsStream("org/activiti/db/mapping/mappings.xml");
  }

  public Set<Class<?>> getCustomMybatisMappers() {
    return this.customMybatisMappers;
  }

  public void setCustomMybatisMappers(Set<Class<?>> customMybatisMappers) {
    this.customMybatisMappers = customMybatisMappers;
  }

  public Set<String> getCustomMybatisXMLMappers() {
    return this.customMybatisXMLMappers;
  }

  public void setCustomMybatisXMLMappers(Set<String> customMybatisXMLMappers) {
    this.customMybatisXMLMappers = customMybatisXMLMappers;
  }

  public void initDataManagers() {
    if (this.attachmentDataManager == null) {
      this.attachmentDataManager = new MybatisAttachmentDataManager(this);
    }

    if (this.byteArrayDataManager == null) {
      this.byteArrayDataManager = new MybatisByteArrayDataManager(this);
    }

    if (this.commentDataManager == null) {
      this.commentDataManager = new MybatisCommentDataManager(this);
    }

    if (this.deploymentDataManager == null) {
      this.deploymentDataManager = new MybatisDeploymentDataManager(this);
    }

    if (this.eventLogEntryDataManager == null) {
      this.eventLogEntryDataManager = new MybatisEventLogEntryDataManager(this);
    }

    if (this.eventSubscriptionDataManager == null) {
      this.eventSubscriptionDataManager = new MybatisEventSubscriptionDataManager(this);
    }

    if (this.executionDataManager == null) {
      this.executionDataManager = new MybatisExecutionDataManager(this);
    }

    if (this.historicActivityInstanceDataManager == null) {
      this.historicActivityInstanceDataManager = new MybatisHistoricActivityInstanceDataManager(this);
    }

    if (this.historicDetailDataManager == null) {
      this.historicDetailDataManager = new MybatisHistoricDetailDataManager(this);
    }

    if (this.historicIdentityLinkDataManager == null) {
      this.historicIdentityLinkDataManager = new MybatisHistoricIdentityLinkDataManager(this);
    }

    if (this.historicProcessInstanceDataManager == null) {
      this.historicProcessInstanceDataManager = new MybatisHistoricProcessInstanceDataManager(this);
    }

    if (this.historicTaskInstanceDataManager == null) {
      this.historicTaskInstanceDataManager = new MybatisHistoricTaskInstanceDataManager(this);
    }

    if (this.historicVariableInstanceDataManager == null) {
      this.historicVariableInstanceDataManager = new MybatisHistoricVariableInstanceDataManager(this);
    }

    if (this.identityLinkDataManager == null) {
      this.identityLinkDataManager = new MybatisIdentityLinkDataManager(this);
    }

    if (this.jobDataManager == null) {
      this.jobDataManager = new MybatisJobDataManager(this);
    }

    if (this.timerJobDataManager == null) {
      this.timerJobDataManager = new MybatisTimerJobDataManager(this);
    }

    if (this.suspendedJobDataManager == null) {
      this.suspendedJobDataManager = new MybatisSuspendedJobDataManager(this);
    }

    if (this.deadLetterJobDataManager == null) {
      this.deadLetterJobDataManager = new MybatisDeadLetterJobDataManager(this);
    }

    if (this.modelDataManager == null) {
      this.modelDataManager = new MybatisModelDataManager(this);
    }

    if (this.processDefinitionDataManager == null) {
      this.processDefinitionDataManager = new MybatisProcessDefinitionDataManager(this);
    }

    if (this.processDefinitionInfoDataManager == null) {
      this.processDefinitionInfoDataManager = new MybatisProcessDefinitionInfoDataManager(this);
    }

    if (this.propertyDataManager == null) {
      this.propertyDataManager = new MybatisPropertyDataManager(this);
    }

    if (this.resourceDataManager == null) {
      this.resourceDataManager = new MybatisResourceDataManager(this);
    }

    if (this.taskDataManager == null) {
      this.taskDataManager = new MybatisTaskDataManager(this);
    }

    if (this.variableInstanceDataManager == null) {
      this.variableInstanceDataManager = new MybatisVariableInstanceDataManager(this);
    }

  }

  public void initEntityManagers() {
    if (this.attachmentEntityManager == null) {
      this.attachmentEntityManager = new AttachmentEntityManagerImpl(this, this.attachmentDataManager);
    }

    if (this.byteArrayEntityManager == null) {
      this.byteArrayEntityManager = new ByteArrayEntityManagerImpl(this, this.byteArrayDataManager);
    }

    if (this.commentEntityManager == null) {
      this.commentEntityManager = new CommentEntityManagerImpl(this, this.commentDataManager);
    }

    if (this.deploymentEntityManager == null) {
      this.deploymentEntityManager = new DeploymentEntityManagerImpl(this, this.deploymentDataManager);
    }

    if (this.eventLogEntryEntityManager == null) {
      this.eventLogEntryEntityManager = new EventLogEntryEntityManagerImpl(this, this.eventLogEntryDataManager);
    }

    if (this.eventSubscriptionEntityManager == null) {
      this.eventSubscriptionEntityManager = new EventSubscriptionEntityManagerImpl(this, this.eventSubscriptionDataManager);
    }

    if (this.executionEntityManager == null) {
      this.executionEntityManager = new ExecutionEntityManagerImpl(this, this.executionDataManager);
    }

    if (this.historicActivityInstanceEntityManager == null) {
      this.historicActivityInstanceEntityManager = new HistoricActivityInstanceEntityManagerImpl(this, this.historicActivityInstanceDataManager);
    }

    if (this.historicDetailEntityManager == null) {
      this.historicDetailEntityManager = new HistoricDetailEntityManagerImpl(this, this.historicDetailDataManager);
    }

    if (this.historicIdentityLinkEntityManager == null) {
      this.historicIdentityLinkEntityManager = new HistoricIdentityLinkEntityManagerImpl(this, this.historicIdentityLinkDataManager);
    }

    if (this.historicProcessInstanceEntityManager == null) {
      this.historicProcessInstanceEntityManager = new HistoricProcessInstanceEntityManagerImpl(this, this.historicProcessInstanceDataManager);
    }

    if (this.historicTaskInstanceEntityManager == null) {
      this.historicTaskInstanceEntityManager = new HistoricTaskInstanceEntityManagerImpl(this, this.historicTaskInstanceDataManager);
    }

    if (this.historicVariableInstanceEntityManager == null) {
      this.historicVariableInstanceEntityManager = new HistoricVariableInstanceEntityManagerImpl(this, this.historicVariableInstanceDataManager);
    }

    if (this.identityLinkEntityManager == null) {
      this.identityLinkEntityManager = new IdentityLinkEntityManagerImpl(this, this.identityLinkDataManager);
    }

    if (this.jobEntityManager == null) {
      this.jobEntityManager = new JobEntityManagerImpl(this, this.jobDataManager);
    }

    if (this.timerJobEntityManager == null) {
      this.timerJobEntityManager = new TimerJobEntityManagerImpl(this, this.timerJobDataManager);
    }

    if (this.suspendedJobEntityManager == null) {
      this.suspendedJobEntityManager = new SuspendedJobEntityManagerImpl(this, this.suspendedJobDataManager);
    }

    if (this.deadLetterJobEntityManager == null) {
      this.deadLetterJobEntityManager = new DeadLetterJobEntityManagerImpl(this, this.deadLetterJobDataManager);
    }

    if (this.modelEntityManager == null) {
      this.modelEntityManager = new ModelEntityManagerImpl(this, this.modelDataManager);
    }

    if (this.processDefinitionEntityManager == null) {
      this.processDefinitionEntityManager = new ProcessDefinitionEntityManagerImpl(this, this.processDefinitionDataManager);
    }

    if (this.processDefinitionInfoEntityManager == null) {
      this.processDefinitionInfoEntityManager = new ProcessDefinitionInfoEntityManagerImpl(this, this.processDefinitionInfoDataManager);
    }

    if (this.propertyEntityManager == null) {
      this.propertyEntityManager = new PropertyEntityManagerImpl(this, this.propertyDataManager);
    }

    if (this.resourceEntityManager == null) {
      this.resourceEntityManager = new ResourceEntityManagerImpl(this, this.resourceDataManager);
    }

    if (this.tableDataManager == null) {
      this.tableDataManager = new TableDataManagerImpl(this);
    }

    if (this.taskEntityManager == null) {
      this.taskEntityManager = new TaskEntityManagerImpl(this, this.taskDataManager);
    }

    if (this.variableInstanceEntityManager == null) {
      this.variableInstanceEntityManager = new VariableInstanceEntityManagerImpl(this, this.variableInstanceDataManager);
    }

  }

  public void initHistoryManager() {
    if (this.historyManager == null) {
      this.historyManager = new MyDefaultHistoryManager(this, this.historyLevel);
    }

  }

  public void initJobManager() {
    if (this.jobManager == null) {
      this.jobManager = new DefaultJobManager(this);
    }

    this.jobManager.setProcessEngineConfiguration(this);
  }

  public void initSessionFactories() {
    if (this.sessionFactories == null) {
      this.sessionFactories = new HashMap();
      if (this.usingRelationalDatabase) {
        this.initDbSqlSessionFactory();
      }

      this.addSessionFactory(new GenericManagerFactory(EntityCache.class, EntityCacheImpl.class));
    }

    if (this.customSessionFactories != null) {
      Iterator var1 = this.customSessionFactories.iterator();

      while(var1.hasNext()) {
        SessionFactory sessionFactory = (SessionFactory)var1.next();
        this.addSessionFactory(sessionFactory);
      }
    }

  }

  public void initDbSqlSessionFactory() {
    if (this.dbSqlSessionFactory == null) {
      this.dbSqlSessionFactory = this.createDbSqlSessionFactory();
    }

    this.dbSqlSessionFactory.setDatabaseType(this.databaseType);
    this.dbSqlSessionFactory.setIdGenerator(this.idGenerator);
    this.dbSqlSessionFactory.setSqlSessionFactory(this.sqlSessionFactory);
    this.dbSqlSessionFactory.setDbHistoryUsed(this.isDbHistoryUsed);
    this.dbSqlSessionFactory.setDatabaseTablePrefix(this.databaseTablePrefix);
    this.dbSqlSessionFactory.setTablePrefixIsSchema(this.tablePrefixIsSchema);
    this.dbSqlSessionFactory.setDatabaseCatalog(this.databaseCatalog);
    this.dbSqlSessionFactory.setDatabaseSchema(this.databaseSchema);
    this.dbSqlSessionFactory.setBulkInsertEnabled(this.isBulkInsertEnabled, this.databaseType);
    this.dbSqlSessionFactory.setMaxNrOfStatementsInBulkInsert(this.maxNrOfStatementsInBulkInsert);
    this.addSessionFactory(this.dbSqlSessionFactory);
  }

  public DbSqlSessionFactory createDbSqlSessionFactory() {
    return new DbSqlSessionFactory();
  }

  public void addSessionFactory(SessionFactory sessionFactory) {
    this.sessionFactories.put(sessionFactory.getSessionType(), sessionFactory);
  }

  public void initConfigurators() {
    this.allConfigurators = new ArrayList();
    if (this.configurators != null) {
      Iterator var1 = this.configurators.iterator();

      while(var1.hasNext()) {
        ProcessEngineConfigurator configurator = (ProcessEngineConfigurator)var1.next();
        this.allConfigurators.add(configurator);
      }
    }

    if (this.enableConfiguratorServiceLoader) {
      ClassLoader classLoader = this.getClassLoader();
      if (classLoader == null) {
        classLoader = ReflectUtil.getClassLoader();
      }

      ServiceLoader<ProcessEngineConfigurator> configuratorServiceLoader = ServiceLoader.load(ProcessEngineConfigurator.class, classLoader);
      int nrOfServiceLoadedConfigurators = 0;

      Iterator var4;
      ProcessEngineConfigurator configurator;
      for(var4 = configuratorServiceLoader.iterator(); var4.hasNext(); ++nrOfServiceLoadedConfigurators) {
        configurator = (ProcessEngineConfigurator)var4.next();
        this.allConfigurators.add(configurator);
      }

      if (nrOfServiceLoadedConfigurators > 0) {
        log.info("Found {} auto-discoverable Process Engine Configurator{}", nrOfServiceLoadedConfigurators++, nrOfServiceLoadedConfigurators > 1 ? "s" : "");
      }

      if (!this.allConfigurators.isEmpty()) {
        Collections.sort(this.allConfigurators, new Comparator<ProcessEngineConfigurator>() {
          public int compare(ProcessEngineConfigurator configurator1, ProcessEngineConfigurator configurator2) {
            int priority1 = configurator1.getPriority();
            int priority2 = configurator2.getPriority();
            if (priority1 < priority2) {
              return -1;
            } else {
              return priority1 > priority2 ? 1 : 0;
            }
          }
        });
        log.info("Found {} Process Engine Configurators in total:", this.allConfigurators.size());
        var4 = this.allConfigurators.iterator();

        while(var4.hasNext()) {
          configurator = (ProcessEngineConfigurator)var4.next();
          log.info("{} (priority:{})", configurator.getClass(), configurator.getPriority());
        }
      }
    }

  }

  public void configuratorsBeforeInit() {
    Iterator var1 = this.allConfigurators.iterator();

    while(var1.hasNext()) {
      ProcessEngineConfigurator configurator = (ProcessEngineConfigurator)var1.next();
      log.info("Executing beforeInit() of {} (priority:{})", configurator.getClass(), configurator.getPriority());
      configurator.beforeInit(this);
    }

  }

  public void configuratorsAfterInit() {
    Iterator var1 = this.allConfigurators.iterator();

    while(var1.hasNext()) {
      ProcessEngineConfigurator configurator = (ProcessEngineConfigurator)var1.next();
      log.info("Executing configure() of {} (priority:{})", configurator.getClass(), configurator.getPriority());
      configurator.configure(this);
    }

  }

  public void initProcessDefinitionCache() {
    if (this.processDefinitionCache == null) {
      if (this.processDefinitionCacheLimit <= 0) {
        this.processDefinitionCache = new DefaultDeploymentCache();
      } else {
        this.processDefinitionCache = new DefaultDeploymentCache(this.processDefinitionCacheLimit);
      }
    }

  }

  public void initProcessDefinitionInfoCache() {
    if (this.processDefinitionInfoCache == null) {
      if (this.processDefinitionInfoCacheLimit <= 0) {
        this.processDefinitionInfoCache = new ProcessDefinitionInfoCache(this.commandExecutor);
      } else {
        this.processDefinitionInfoCache = new ProcessDefinitionInfoCache(this.commandExecutor, this.processDefinitionInfoCacheLimit);
      }
    }

  }

  public void initKnowledgeBaseCache() {
    if (this.knowledgeBaseCache == null) {
      if (this.knowledgeBaseCacheLimit <= 0) {
        this.knowledgeBaseCache = new DefaultDeploymentCache();
      } else {
        this.knowledgeBaseCache = new DefaultDeploymentCache(this.knowledgeBaseCacheLimit);
      }
    }

  }

  public void initDeployers() {
    if (this.deployers == null) {
      this.deployers = new ArrayList();
      if (this.customPreDeployers != null) {
        this.deployers.addAll(this.customPreDeployers);
      }

      this.deployers.addAll(this.getDefaultDeployers());
      if (this.customPostDeployers != null) {
        this.deployers.addAll(this.customPostDeployers);
      }
    }

    if (this.deploymentManager == null) {
      this.deploymentManager = new DeploymentManager();
      this.deploymentManager.setDeployers(this.deployers);
      this.deploymentManager.setProcessDefinitionCache(this.processDefinitionCache);
      this.deploymentManager.setProcessDefinitionInfoCache(this.processDefinitionInfoCache);
      this.deploymentManager.setKnowledgeBaseCache(this.knowledgeBaseCache);
      this.deploymentManager.setProcessEngineConfiguration(this);
      this.deploymentManager.setProcessDefinitionEntityManager(this.processDefinitionEntityManager);
      this.deploymentManager.setDeploymentEntityManager(this.deploymentEntityManager);
    }

  }

  public void initBpmnDeployerDependencies() {
    if (this.parsedDeploymentBuilderFactory == null) {
      this.parsedDeploymentBuilderFactory = new ParsedDeploymentBuilderFactory();
    }

    if (this.parsedDeploymentBuilderFactory.getBpmnParser() == null) {
      this.parsedDeploymentBuilderFactory.setBpmnParser(this.bpmnParser);
    }

    if (this.timerManager == null) {
      this.timerManager = new TimerManager();
    }

    if (this.eventSubscriptionManager == null) {
      this.eventSubscriptionManager = new EventSubscriptionManager();
    }

    if (this.bpmnDeploymentHelper == null) {
      this.bpmnDeploymentHelper = new BpmnDeploymentHelper();
    }

    if (this.bpmnDeploymentHelper.getTimerManager() == null) {
      this.bpmnDeploymentHelper.setTimerManager(this.timerManager);
    }

    if (this.bpmnDeploymentHelper.getEventSubscriptionManager() == null) {
      this.bpmnDeploymentHelper.setEventSubscriptionManager(this.eventSubscriptionManager);
    }

    if (this.cachingAndArtifactsManager == null) {
      this.cachingAndArtifactsManager = new CachingAndArtifactsManager();
    }

  }

  public Collection<? extends Deployer> getDefaultDeployers() {
    List<Deployer> defaultDeployers = new ArrayList();
    if (this.bpmnDeployer == null) {
      this.bpmnDeployer = new BpmnDeployer();
    }

    this.initBpmnDeployerDependencies();
    this.bpmnDeployer.setIdGenerator(this.idGenerator);
    this.bpmnDeployer.setParsedDeploymentBuilderFactory(this.parsedDeploymentBuilderFactory);
    this.bpmnDeployer.setBpmnDeploymentHelper(this.bpmnDeploymentHelper);
    this.bpmnDeployer.setCachingAndArtifactsManager(this.cachingAndArtifactsManager);
    defaultDeployers.add(this.bpmnDeployer);
    return defaultDeployers;
  }

  public void initListenerFactory() {
    if (this.listenerFactory == null) {
      DefaultListenerFactory defaultListenerFactory = new DefaultListenerFactory();
      defaultListenerFactory.setExpressionManager(this.expressionManager);
      this.listenerFactory = defaultListenerFactory;
    } else if (this.listenerFactory instanceof AbstractBehaviorFactory && ((AbstractBehaviorFactory)this.listenerFactory).getExpressionManager() == null) {
      ((AbstractBehaviorFactory)this.listenerFactory).setExpressionManager(this.expressionManager);
    }

  }

  public void initBehaviorFactory() {
    if (this.activityBehaviorFactory == null) {
      DefaultActivityBehaviorFactory defaultActivityBehaviorFactory = new DefaultActivityBehaviorFactory();
      defaultActivityBehaviorFactory.setExpressionManager(this.expressionManager);
      this.activityBehaviorFactory = defaultActivityBehaviorFactory;
    } else if (this.activityBehaviorFactory instanceof AbstractBehaviorFactory && ((AbstractBehaviorFactory)this.activityBehaviorFactory).getExpressionManager() == null) {
      ((AbstractBehaviorFactory)this.activityBehaviorFactory).setExpressionManager(this.expressionManager);
    }

  }

  public void initBpmnParser() {
    if (this.bpmnParser == null) {
      this.bpmnParser = new BpmnParser();
    }

    if (this.bpmnParseFactory == null) {
      this.bpmnParseFactory = new DefaultBpmnParseFactory();
    }

    this.bpmnParser.setBpmnParseFactory(this.bpmnParseFactory);
    this.bpmnParser.setActivityBehaviorFactory(this.activityBehaviorFactory);
    this.bpmnParser.setListenerFactory(this.listenerFactory);
    List<BpmnParseHandler> parseHandlers = new ArrayList();
    if (this.getPreBpmnParseHandlers() != null) {
      parseHandlers.addAll(this.getPreBpmnParseHandlers());
    }

    parseHandlers.addAll(this.getDefaultBpmnParseHandlers());
    if (this.getPostBpmnParseHandlers() != null) {
      parseHandlers.addAll(this.getPostBpmnParseHandlers());
    }

    BpmnParseHandlers bpmnParseHandlers = new BpmnParseHandlers();
    bpmnParseHandlers.addHandlers(parseHandlers);
    this.bpmnParser.setBpmnParserHandlers(bpmnParseHandlers);
  }

  public List<BpmnParseHandler> getDefaultBpmnParseHandlers() {
    List<BpmnParseHandler> bpmnParserHandlers = new ArrayList();
    bpmnParserHandlers.add(new BoundaryEventParseHandler());
    bpmnParserHandlers.add(new BusinessRuleParseHandler());
    bpmnParserHandlers.add(new CallActivityParseHandler());
    bpmnParserHandlers.add(new CancelEventDefinitionParseHandler());
    bpmnParserHandlers.add(new CompensateEventDefinitionParseHandler());
    bpmnParserHandlers.add(new EndEventParseHandler());
    bpmnParserHandlers.add(new ErrorEventDefinitionParseHandler());
    bpmnParserHandlers.add(new EventBasedGatewayParseHandler());
    bpmnParserHandlers.add(new ExclusiveGatewayParseHandler());
    bpmnParserHandlers.add(new InclusiveGatewayParseHandler());
    bpmnParserHandlers.add(new IntermediateCatchEventParseHandler());
    bpmnParserHandlers.add(new IntermediateThrowEventParseHandler());
    bpmnParserHandlers.add(new ManualTaskParseHandler());
    bpmnParserHandlers.add(new MessageEventDefinitionParseHandler());
    bpmnParserHandlers.add(new ParallelGatewayParseHandler());
    bpmnParserHandlers.add(new ProcessParseHandler());
    bpmnParserHandlers.add(new ReceiveTaskParseHandler());
    bpmnParserHandlers.add(new ScriptTaskParseHandler());
    bpmnParserHandlers.add(new SendTaskParseHandler());
    bpmnParserHandlers.add(new SequenceFlowParseHandler());
    bpmnParserHandlers.add(new ServiceTaskParseHandler());
    bpmnParserHandlers.add(new SignalEventDefinitionParseHandler());
    bpmnParserHandlers.add(new StartEventParseHandler());
    bpmnParserHandlers.add(new SubProcessParseHandler());
    bpmnParserHandlers.add(new EventSubProcessParseHandler());
    bpmnParserHandlers.add(new AdhocSubProcessParseHandler());
    bpmnParserHandlers.add(new TaskParseHandler());
    bpmnParserHandlers.add(new TimerEventDefinitionParseHandler());
    bpmnParserHandlers.add(new TransactionParseHandler());
    bpmnParserHandlers.add(new UserTaskParseHandler());
    if (this.customDefaultBpmnParseHandlers != null) {
      Map<Class<?>, BpmnParseHandler> customParseHandlerMap = new HashMap();
      Iterator var3 = this.customDefaultBpmnParseHandlers.iterator();

      BpmnParseHandler defaultBpmnParseHandler;
      while(var3.hasNext()) {
        defaultBpmnParseHandler = (BpmnParseHandler)var3.next();
        Iterator var5 = defaultBpmnParseHandler.getHandledTypes().iterator();

        while(var5.hasNext()) {
          Class<?> handledType = (Class)var5.next();
          customParseHandlerMap.put(handledType, defaultBpmnParseHandler);
        }
      }

      for(int i = 0; i < bpmnParserHandlers.size(); ++i) {
        defaultBpmnParseHandler = (BpmnParseHandler)bpmnParserHandlers.get(i);
        if (defaultBpmnParseHandler.getHandledTypes().size() != 1) {
          StringBuilder supportedTypes = new StringBuilder();
          Iterator var12 = defaultBpmnParseHandler.getHandledTypes().iterator();

          while(var12.hasNext()) {
            Class<?> type = (Class)var12.next();
            supportedTypes.append(" ").append(type.getCanonicalName()).append(" ");
          }

          throw new ActivitiException("The default BPMN parse handlers should only support one type, but " + defaultBpmnParseHandler.getClass() + " supports " + supportedTypes.toString() + ". This is likely a programmatic error");
        }

        Class<?> handledType = (Class)defaultBpmnParseHandler.getHandledTypes().iterator().next();
        if (customParseHandlerMap.containsKey(handledType)) {
          BpmnParseHandler newBpmnParseHandler = (BpmnParseHandler)customParseHandlerMap.get(handledType);
          log.info("Replacing default BpmnParseHandler " + defaultBpmnParseHandler.getClass().getName() + " with " + newBpmnParseHandler.getClass().getName());
          bpmnParserHandlers.set(i, newBpmnParseHandler);
        }
      }
    }

    return bpmnParserHandlers;
  }

  public void initClock() {
    if (this.clock == null) {
      this.clock = new DefaultClockImpl();
    }

  }

  public void initAgendaFactory() {
    if (this.engineAgendaFactory == null) {
      this.engineAgendaFactory = new DefaultActivitiEngineAgendaFactory();
    }

  }

  public void initJobHandlers() {
    this.jobHandlers = new HashMap();
    AsyncContinuationJobHandler asyncContinuationJobHandler = new AsyncContinuationJobHandler();
    this.jobHandlers.put(asyncContinuationJobHandler.getType(), asyncContinuationJobHandler);
    TriggerTimerEventJobHandler triggerTimerEventJobHandler = new TriggerTimerEventJobHandler();
    this.jobHandlers.put(triggerTimerEventJobHandler.getType(), triggerTimerEventJobHandler);
    TimerStartEventJobHandler timerStartEvent = new TimerStartEventJobHandler();
    this.jobHandlers.put(timerStartEvent.getType(), timerStartEvent);
    TimerSuspendProcessDefinitionHandler suspendProcessDefinitionHandler = new TimerSuspendProcessDefinitionHandler();
    this.jobHandlers.put(suspendProcessDefinitionHandler.getType(), suspendProcessDefinitionHandler);
    TimerActivateProcessDefinitionHandler activateProcessDefinitionHandler = new TimerActivateProcessDefinitionHandler();
    this.jobHandlers.put(activateProcessDefinitionHandler.getType(), activateProcessDefinitionHandler);
    ProcessEventJobHandler processEventJobHandler = new ProcessEventJobHandler();
    this.jobHandlers.put(processEventJobHandler.getType(), processEventJobHandler);
    if (this.getCustomJobHandlers() != null) {
      Iterator var7 = this.getCustomJobHandlers().iterator();

      while(var7.hasNext()) {
        JobHandler customJobHandler = (JobHandler)var7.next();
        this.jobHandlers.put(customJobHandler.getType(), customJobHandler);
      }
    }

  }

  public void initAsyncExecutor() {
    if (this.asyncExecutor == null) {
      DefaultAsyncJobExecutor defaultAsyncExecutor = new DefaultAsyncJobExecutor();
      defaultAsyncExecutor.applyConfig(this);
      this.asyncExecutor = defaultAsyncExecutor;
    }

    this.asyncExecutor.setProcessEngineConfiguration(this);
    this.asyncExecutor.setAutoActivate(this.asyncExecutorActivate);
  }

  public void initHistoryLevel() {
    if (this.historyLevel == null) {
      this.historyLevel = HistoryLevel.getHistoryLevelForKey(this.getHistory());
    }

  }

  public void initIdGenerator() {
    if (this.idGenerator == null) {
      CommandExecutor idGeneratorCommandExecutor = null;
      StandaloneProcessEngineConfiguration processEngineConfiguration;
      if (this.idGeneratorDataSource != null) {
        processEngineConfiguration = new StandaloneProcessEngineConfiguration();
        processEngineConfiguration.setDataSource(this.idGeneratorDataSource);
        processEngineConfiguration.setDatabaseSchemaUpdate("false");
        processEngineConfiguration.init();
        idGeneratorCommandExecutor = processEngineConfiguration.getCommandExecutor();
      } else if (this.idGeneratorDataSourceJndiName != null) {
        processEngineConfiguration = new StandaloneProcessEngineConfiguration();
        processEngineConfiguration.setDataSourceJndiName(this.idGeneratorDataSourceJndiName);
        processEngineConfiguration.setDatabaseSchemaUpdate("false");
        processEngineConfiguration.init();
        idGeneratorCommandExecutor = processEngineConfiguration.getCommandExecutor();
      } else {
        idGeneratorCommandExecutor = this.getCommandExecutor();
      }

      DbIdGenerator dbIdGenerator = new DbIdGenerator();
      dbIdGenerator.setIdBlockSize(this.idBlockSize);
      dbIdGenerator.setCommandExecutor(idGeneratorCommandExecutor);
      dbIdGenerator.setCommandConfig(this.getDefaultCommandConfig().transactionRequiresNew());
      this.idGenerator = dbIdGenerator;
    }

  }

  public void initCommandContextFactory() {
    if (this.commandContextFactory == null) {
      this.commandContextFactory = new CommandContextFactory();
    }

    this.commandContextFactory.setProcessEngineConfiguration(this);
  }

  public void initTransactionContextFactory() {
    if (this.transactionContextFactory == null) {
      this.transactionContextFactory = new StandaloneMybatisTransactionContextFactory();
    }

  }

  public void initHelpers() {
    if (this.processInstanceHelper == null) {
      this.processInstanceHelper = new ProcessInstanceHelper();
    }

    if (this.listenerNotificationHelper == null) {
      this.listenerNotificationHelper = new ListenerNotificationHelper();
    }

  }

  public void initVariableTypes() {
    if (this.variableTypes == null) {
      this.variableTypes = new DefaultVariableTypes();
      if (this.customPreVariableTypes != null) {
        Iterator var1 = this.customPreVariableTypes.iterator();

        while(var1.hasNext()) {
          VariableType customVariableType = (VariableType)var1.next();
          this.variableTypes.addType(customVariableType);
        }
      }

      this.variableTypes.addType(new NullType());
      this.variableTypes.addType(new StringType(this.getMaxLengthString()));
      this.variableTypes.addType(new LongStringType(this.getMaxLengthString() + 1));
      this.variableTypes.addType(new BooleanType());
      this.variableTypes.addType(new ShortType());
      this.variableTypes.addType(new IntegerType());
      this.variableTypes.addType(new LongType());
      this.variableTypes.addType(new DateType());
      this.variableTypes.addType(new JodaDateType());
      this.variableTypes.addType(new JodaDateTimeType());
      this.variableTypes.addType(new DoubleType());
      this.variableTypes.addType(new UUIDType());
      JsonTypeConverter jsonTypeConverter = new JsonTypeConverter(this.objectMapper, this.javaClassFieldForJackson);
      this.variableTypes.addType(new JsonType(this.getMaxLengthString(), this.objectMapper, this.serializePOJOsInVariablesToJson, jsonTypeConverter));
      this.variableTypes.addType(new LongJsonType(this.getMaxLengthString() + 1, this.objectMapper, this.serializePOJOsInVariablesToJson, jsonTypeConverter));
      if (!this.serializePOJOsInVariablesToJson) {
        this.variableTypes.addType(new ByteArrayType());
        this.variableTypes.addType(new SerializableType(this.serializableVariableTypeTrackDeserializedObjects));
        this.variableTypes.addType(new CustomObjectType("item", ItemInstance.class));
        this.variableTypes.addType(new CustomObjectType("message", MessageInstance.class));
      }

      if (this.customPostVariableTypes != null) {
        Iterator var5 = this.customPostVariableTypes.iterator();

        while(var5.hasNext()) {
          VariableType customVariableType = (VariableType)var5.next();
          this.variableTypes.addType(customVariableType);
        }
      }
    }

  }

  public int getMaxLengthString() {
    if (this.maxLengthStringVariableType == -1) {
      return "oracle".equalsIgnoreCase(this.databaseType) ? 2000 : 4000;
    } else {
      return this.maxLengthStringVariableType;
    }
  }

  public void initScriptingEngines() {
    if (this.resolverFactories == null) {
      this.resolverFactories = new ArrayList();
      this.resolverFactories.add(new VariableScopeResolverFactory());
      this.resolverFactories.add(new BeansResolverFactory());
    }

    if (this.scriptingEngines == null) {
      this.scriptingEngines = new ScriptingEngines(new ScriptBindingsFactory(this, this.resolverFactories));
    }

  }

  public void initExpressionManager() {
    if (this.expressionManager == null) {
      this.expressionManager = new ExpressionManager(this.beans);
    }

  }

  public void initBusinessCalendarManager() {
    if (this.businessCalendarManager == null) {
      MapBusinessCalendarManager mapBusinessCalendarManager = new MapBusinessCalendarManager();
      mapBusinessCalendarManager.addBusinessCalendar(DurationBusinessCalendar.NAME, new DurationBusinessCalendar(this.clock));
      mapBusinessCalendarManager.addBusinessCalendar("dueDate", new DueDateBusinessCalendar(this.clock));
      mapBusinessCalendarManager.addBusinessCalendar(CycleBusinessCalendar.NAME, new CycleBusinessCalendar(this.clock));
      this.businessCalendarManager = mapBusinessCalendarManager;
    }

  }

  public void initDelegateInterceptor() {
    if (this.delegateInterceptor == null) {
      this.delegateInterceptor = new DefaultDelegateInterceptor();
    }

  }

  public void initEventHandlers() {
    if (this.eventHandlers == null) {
      this.eventHandlers = new HashMap();
      SignalEventHandler signalEventHandler = new SignalEventHandler();
      this.eventHandlers.put(signalEventHandler.getEventHandlerType(), signalEventHandler);
      CompensationEventHandler compensationEventHandler = new CompensationEventHandler();
      this.eventHandlers.put(compensationEventHandler.getEventHandlerType(), compensationEventHandler);
      MessageEventHandler messageEventHandler = new MessageEventHandler(this.eventSubscriptionPayloadMappingProvider);
      this.eventHandlers.put(messageEventHandler.getEventHandlerType(), messageEventHandler);
    }

    if (this.customEventHandlers != null) {
      Iterator var4 = this.customEventHandlers.iterator();

      while(var4.hasNext()) {
        EventHandler eventHandler = (EventHandler)var4.next();
        this.eventHandlers.put(eventHandler.getEventHandlerType(), eventHandler);
      }
    }

  }

  public void initJpa() {
    if (this.jpaPersistenceUnitName != null) {
      this.jpaEntityManagerFactory = JpaHelper.createEntityManagerFactory(this.jpaPersistenceUnitName);
    }

    if (this.jpaEntityManagerFactory != null) {
      this.sessionFactories.put(EntityManagerSession.class, new EntityManagerSessionFactory(this.jpaEntityManagerFactory, this.jpaHandleTransaction, this.jpaCloseEntityManager));
      VariableType jpaType = this.variableTypes.getVariableType("jpa-entity");
      if (jpaType == null) {
        int serializableIndex = this.variableTypes.getTypeIndex("serializable");
        if (serializableIndex > -1) {
          this.variableTypes.addType(new JPAEntityVariableType(), serializableIndex);
        } else {
          this.variableTypes.addType(new JPAEntityVariableType());
        }
      }

      jpaType = this.variableTypes.getVariableType("jpa-entity-list");
      if (jpaType == null) {
        this.variableTypes.addType(new JPAEntityListVariableType(), this.variableTypes.getTypeIndex("jpa-entity"));
      }
    }

  }

  public void initBeans() {
    if (this.beans == null) {
      this.beans = new HashMap();
    }

  }

  public void initEventDispatcher() {
    if (this.eventDispatcher == null) {
      this.eventDispatcher = new ActivitiEventDispatcherImpl();
    }

    this.eventDispatcher.setEnabled(this.enableEventDispatcher);
    Iterator var1;
    if (this.eventListeners != null) {
      var1 = this.eventListeners.iterator();

      while(var1.hasNext()) {
        ActivitiEventListener listenerToAdd = (ActivitiEventListener)var1.next();
        this.eventDispatcher.addEventListener(listenerToAdd);
      }
    }

    if (this.typedEventListeners != null) {
      var1 = this.typedEventListeners.entrySet().iterator();

      while(var1.hasNext()) {
        Map.Entry<String, List<ActivitiEventListener>> listenersToAdd = (Map.Entry)var1.next();
        ActivitiEventType[] types = ActivitiEventType.getTypesFromString((String)listenersToAdd.getKey());
        Iterator var4 = ((List)listenersToAdd.getValue()).iterator();

        while(var4.hasNext()) {
          ActivitiEventListener listenerToAdd = (ActivitiEventListener)var4.next();
          this.eventDispatcher.addEventListener(listenerToAdd, types);
        }
      }
    }

  }

  public void initProcessValidator() {
    if (this.processValidator == null) {
      this.processValidator = (new ProcessValidatorFactory()).createDefaultProcessValidator();
    }

  }

  public void initDatabaseEventLogging() {
    if (this.enableDatabaseEventLogging) {
      this.getEventDispatcher().addEventListener(new EventLogger(this.clock, this.objectMapper));
    }

  }

  protected void postProcessEngineInitialisation() {
    if (this.performanceSettings.isValidateExecutionRelationshipCountConfigOnBoot()) {
      this.commandExecutor.execute(new ValidateExecutionRelatedEntityCountCfgCmd());
    }

  }

  public CommandConfig getDefaultCommandConfig() {
    return this.defaultCommandConfig;
  }

  public void setDefaultCommandConfig(CommandConfig defaultCommandConfig) {
    this.defaultCommandConfig = defaultCommandConfig;
  }

  public CommandConfig getSchemaCommandConfig() {
    return this.schemaCommandConfig;
  }

  public void setSchemaCommandConfig(CommandConfig schemaCommandConfig) {
    this.schemaCommandConfig = schemaCommandConfig;
  }

  public CommandInterceptor getCommandInvoker() {
    return this.commandInvoker;
  }

  public void setCommandInvoker(CommandInterceptor commandInvoker) {
    this.commandInvoker = commandInvoker;
  }

  public List<CommandInterceptor> getCustomPreCommandInterceptors() {
    return this.customPreCommandInterceptors;
  }

  public ProcessEngineConfigurationImpl setCustomPreCommandInterceptors(List<CommandInterceptor> customPreCommandInterceptors) {
    this.customPreCommandInterceptors = customPreCommandInterceptors;
    return this;
  }

  public List<CommandInterceptor> getCustomPostCommandInterceptors() {
    return this.customPostCommandInterceptors;
  }

  public ProcessEngineConfigurationImpl setCustomPostCommandInterceptors(List<CommandInterceptor> customPostCommandInterceptors) {
    this.customPostCommandInterceptors = customPostCommandInterceptors;
    return this;
  }

  public List<CommandInterceptor> getCommandInterceptors() {
    return this.commandInterceptors;
  }

  public ProcessEngineConfigurationImpl setCommandInterceptors(List<CommandInterceptor> commandInterceptors) {
    this.commandInterceptors = commandInterceptors;
    return this;
  }

  public CommandExecutor getCommandExecutor() {
    return this.commandExecutor;
  }

  public ProcessEngineConfigurationImpl setCommandExecutor(CommandExecutor commandExecutor) {
    this.commandExecutor = commandExecutor;
    return this;
  }

  public RepositoryService getRepositoryService() {
    return this.repositoryService;
  }

  public ProcessEngineConfigurationImpl setRepositoryService(RepositoryService repositoryService) {
    this.repositoryService = repositoryService;
    return this;
  }

  public RuntimeService getRuntimeService() {
    return this.runtimeService;
  }

  public ProcessEngineConfigurationImpl setRuntimeService(RuntimeService runtimeService) {
    this.runtimeService = runtimeService;
    return this;
  }

  public HistoryService getHistoryService() {
    return this.historyService;
  }

  public ProcessEngineConfigurationImpl setHistoryService(HistoryService historyService) {
    this.historyService = historyService;
    return this;
  }

  public TaskService getTaskService() {
    return this.taskService;
  }

  public ProcessEngineConfigurationImpl setTaskService(TaskService taskService) {
    this.taskService = taskService;
    return this;
  }

  public ManagementService getManagementService() {
    return this.managementService;
  }

  public ProcessEngineConfigurationImpl setManagementService(ManagementService managementService) {
    this.managementService = managementService;
    return this;
  }

  public DynamicBpmnService getDynamicBpmnService() {
    return this.dynamicBpmnService;
  }

  public ProcessEngineConfigurationImpl setDynamicBpmnService(DynamicBpmnService dynamicBpmnService) {
    this.dynamicBpmnService = dynamicBpmnService;
    return this;
  }

  public void setUserGroupManager(UserGroupManager userGroupManager) {
    this.userGroupManager = userGroupManager;
  }

  public UserGroupManager getUserGroupManager() {
    return this.userGroupManager;
  }

  public IntegrationContextManager getIntegrationContextManager() {
    if (this.integrationContextManager == null) {
      this.integrationContextManager = new IntegrationContextManagerImpl(this, this.getIntegrationContextDataManager());
    }

    return this.integrationContextManager;
  }

  private IntegrationContextDataManager getIntegrationContextDataManager() {
    if (this.integrationContextDataManager == null) {
      this.integrationContextDataManager = new MybatisIntegrationContextDataManager(this);
    }

    return this.integrationContextDataManager;
  }

  public IntegrationContextService getIntegrationContextService() {
    if (this.integrationContextService == null) {
      this.integrationContextService = new IntegrationContextServiceImpl(this.commandExecutor);
    }

    return this.integrationContextService;
  }

  public ProcessEngineConfigurationImpl getProcessEngineConfiguration() {
    return this;
  }

  public Map<Class<?>, SessionFactory> getSessionFactories() {
    return this.sessionFactories;
  }

  public ProcessEngineConfigurationImpl setSessionFactories(Map<Class<?>, SessionFactory> sessionFactories) {
    this.sessionFactories = sessionFactories;
    return this;
  }

  public List<ProcessEngineConfigurator> getConfigurators() {
    return this.configurators;
  }

  public ProcessEngineConfigurationImpl addConfigurator(ProcessEngineConfigurator configurator) {
    if (this.configurators == null) {
      this.configurators = new ArrayList();
    }

    this.configurators.add(configurator);
    return this;
  }

  public ProcessEngineConfigurationImpl setConfigurators(List<ProcessEngineConfigurator> configurators) {
    this.configurators = configurators;
    return this;
  }

  public void setEnableConfiguratorServiceLoader(boolean enableConfiguratorServiceLoader) {
    this.enableConfiguratorServiceLoader = enableConfiguratorServiceLoader;
  }

  public List<ProcessEngineConfigurator> getAllConfigurators() {
    return this.allConfigurators;
  }

  public BpmnDeployer getBpmnDeployer() {
    return this.bpmnDeployer;
  }

  public ProcessEngineConfigurationImpl setBpmnDeployer(BpmnDeployer bpmnDeployer) {
    this.bpmnDeployer = bpmnDeployer;
    return this;
  }

  public BpmnParser getBpmnParser() {
    return this.bpmnParser;
  }

  public ProcessEngineConfigurationImpl setBpmnParser(BpmnParser bpmnParser) {
    this.bpmnParser = bpmnParser;
    return this;
  }

  public ParsedDeploymentBuilderFactory getParsedDeploymentBuilderFactory() {
    return this.parsedDeploymentBuilderFactory;
  }

  public ProcessEngineConfigurationImpl setParsedDeploymentBuilderFactory(ParsedDeploymentBuilderFactory parsedDeploymentBuilderFactory) {
    this.parsedDeploymentBuilderFactory = parsedDeploymentBuilderFactory;
    return this;
  }

  public TimerManager getTimerManager() {
    return this.timerManager;
  }

  public void setTimerManager(TimerManager timerManager) {
    this.timerManager = timerManager;
  }

  public EventSubscriptionManager getEventSubscriptionManager() {
    return this.eventSubscriptionManager;
  }

  public void setEventSubscriptionManager(EventSubscriptionManager eventSubscriptionManager) {
    this.eventSubscriptionManager = eventSubscriptionManager;
  }

  public BpmnDeploymentHelper getBpmnDeploymentHelper() {
    return this.bpmnDeploymentHelper;
  }

  public ProcessEngineConfigurationImpl setBpmnDeploymentHelper(BpmnDeploymentHelper bpmnDeploymentHelper) {
    this.bpmnDeploymentHelper = bpmnDeploymentHelper;
    return this;
  }

  public CachingAndArtifactsManager getCachingAndArtifactsManager() {
    return this.cachingAndArtifactsManager;
  }

  public void setCachingAndArtifactsManager(CachingAndArtifactsManager cachingAndArtifactsManager) {
    this.cachingAndArtifactsManager = cachingAndArtifactsManager;
  }

  public List<Deployer> getDeployers() {
    return this.deployers;
  }

  public ProcessEngineConfigurationImpl setDeployers(List<Deployer> deployers) {
    this.deployers = deployers;
    return this;
  }

  public IdGenerator getIdGenerator() {
    return this.idGenerator;
  }

  public ProcessEngineConfigurationImpl setIdGenerator(IdGenerator idGenerator) {
    this.idGenerator = idGenerator;
    return this;
  }

  public String getWsSyncFactoryClassName() {
    return this.wsSyncFactoryClassName;
  }

  public ProcessEngineConfigurationImpl setWsSyncFactoryClassName(String wsSyncFactoryClassName) {
    this.wsSyncFactoryClassName = wsSyncFactoryClassName;
    return this;
  }

  public ProcessEngineConfiguration addWsEndpointAddress(QName endpointName, URL address) {
    this.wsOverridenEndpointAddresses.put(endpointName, address);
    return this;
  }

  public ProcessEngineConfiguration removeWsEndpointAddress(QName endpointName) {
    this.wsOverridenEndpointAddresses.remove(endpointName);
    return this;
  }

  public ConcurrentMap<QName, URL> getWsOverridenEndpointAddresses() {
    return this.wsOverridenEndpointAddresses;
  }

  public ProcessEngineConfiguration setWsOverridenEndpointAddresses(ConcurrentMap<QName, URL> wsOverridenEndpointAddress) {
    this.wsOverridenEndpointAddresses.putAll(wsOverridenEndpointAddress);
    return this;
  }

  public ScriptingEngines getScriptingEngines() {
    return this.scriptingEngines;
  }

  public ProcessEngineConfigurationImpl setScriptingEngines(ScriptingEngines scriptingEngines) {
    this.scriptingEngines = scriptingEngines;
    return this;
  }

  public VariableTypes getVariableTypes() {
    return this.variableTypes;
  }

  public ProcessEngineConfigurationImpl setVariableTypes(VariableTypes variableTypes) {
    this.variableTypes = variableTypes;
    return this;
  }

  public boolean isSerializableVariableTypeTrackDeserializedObjects() {
    return this.serializableVariableTypeTrackDeserializedObjects;
  }

  public void setSerializableVariableTypeTrackDeserializedObjects(boolean serializableVariableTypeTrackDeserializedObjects) {
    this.serializableVariableTypeTrackDeserializedObjects = serializableVariableTypeTrackDeserializedObjects;
  }

  public boolean isSerializePOJOsInVariablesToJson() {
    return this.serializePOJOsInVariablesToJson;
  }

  public void setSerializePOJOsInVariablesToJson(boolean serializePOJOsInVariablesToJson) {
    this.serializePOJOsInVariablesToJson = serializePOJOsInVariablesToJson;
  }

  public String getJavaClassFieldForJackson() {
    return this.javaClassFieldForJackson;
  }

  public void setJavaClassFieldForJackson(String javaClassFieldForJackson) {
    this.javaClassFieldForJackson = javaClassFieldForJackson;
  }

  public ExpressionManager getExpressionManager() {
    return this.expressionManager;
  }

  public ProcessEngineConfigurationImpl setExpressionManager(ExpressionManager expressionManager) {
    this.expressionManager = expressionManager;
    return this;
  }

  public BusinessCalendarManager getBusinessCalendarManager() {
    return this.businessCalendarManager;
  }

  public ProcessEngineConfigurationImpl setBusinessCalendarManager(BusinessCalendarManager businessCalendarManager) {
    this.businessCalendarManager = businessCalendarManager;
    return this;
  }

  public int getExecutionQueryLimit() {
    return this.executionQueryLimit;
  }

  public ProcessEngineConfigurationImpl setExecutionQueryLimit(int executionQueryLimit) {
    this.executionQueryLimit = executionQueryLimit;
    return this;
  }

  public int getTaskQueryLimit() {
    return this.taskQueryLimit;
  }

  public ProcessEngineConfigurationImpl setTaskQueryLimit(int taskQueryLimit) {
    this.taskQueryLimit = taskQueryLimit;
    return this;
  }

  public int getHistoricTaskQueryLimit() {
    return this.historicTaskQueryLimit;
  }

  public ProcessEngineConfigurationImpl setHistoricTaskQueryLimit(int historicTaskQueryLimit) {
    this.historicTaskQueryLimit = historicTaskQueryLimit;
    return this;
  }

  public int getHistoricProcessInstancesQueryLimit() {
    return this.historicProcessInstancesQueryLimit;
  }

  public ProcessEngineConfigurationImpl setHistoricProcessInstancesQueryLimit(int historicProcessInstancesQueryLimit) {
    this.historicProcessInstancesQueryLimit = historicProcessInstancesQueryLimit;
    return this;
  }

  public CommandContextFactory getCommandContextFactory() {
    return this.commandContextFactory;
  }

  public ProcessEngineConfigurationImpl setCommandContextFactory(CommandContextFactory commandContextFactory) {
    this.commandContextFactory = commandContextFactory;
    return this;
  }

  public TransactionContextFactory getTransactionContextFactory() {
    return this.transactionContextFactory;
  }

  public ProcessEngineConfigurationImpl setTransactionContextFactory(TransactionContextFactory transactionContextFactory) {
    this.transactionContextFactory = transactionContextFactory;
    return this;
  }

  public List<Deployer> getCustomPreDeployers() {
    return this.customPreDeployers;
  }

  public ProcessEngineConfigurationImpl setCustomPreDeployers(List<Deployer> customPreDeployers) {
    this.customPreDeployers = customPreDeployers;
    return this;
  }

  public List<Deployer> getCustomPostDeployers() {
    return this.customPostDeployers;
  }

  public ProcessEngineConfigurationImpl setCustomPostDeployers(List<Deployer> customPostDeployers) {
    this.customPostDeployers = customPostDeployers;
    return this;
  }

  public Map<String, JobHandler> getJobHandlers() {
    return this.jobHandlers;
  }

  public ProcessEngineConfigurationImpl setJobHandlers(Map<String, JobHandler> jobHandlers) {
    this.jobHandlers = jobHandlers;
    return this;
  }

  public ProcessInstanceHelper getProcessInstanceHelper() {
    return this.processInstanceHelper;
  }

  public ProcessEngineConfigurationImpl setProcessInstanceHelper(ProcessInstanceHelper processInstanceHelper) {
    this.processInstanceHelper = processInstanceHelper;
    return this;
  }

  public ListenerNotificationHelper getListenerNotificationHelper() {
    return this.listenerNotificationHelper;
  }

  public ProcessEngineConfigurationImpl setListenerNotificationHelper(ListenerNotificationHelper listenerNotificationHelper) {
    this.listenerNotificationHelper = listenerNotificationHelper;
    return this;
  }

  public SqlSessionFactory getSqlSessionFactory() {
    return this.sqlSessionFactory;
  }

  public ProcessEngineConfigurationImpl setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
    this.sqlSessionFactory = sqlSessionFactory;
    return this;
  }

  public DbSqlSessionFactory getDbSqlSessionFactory() {
    return this.dbSqlSessionFactory;
  }

  public ProcessEngineConfigurationImpl setDbSqlSessionFactory(DbSqlSessionFactory dbSqlSessionFactory) {
    this.dbSqlSessionFactory = dbSqlSessionFactory;
    return this;
  }

  public TransactionFactory getTransactionFactory() {
    return this.transactionFactory;
  }

  public ProcessEngineConfigurationImpl setTransactionFactory(TransactionFactory transactionFactory) {
    this.transactionFactory = transactionFactory;
    return this;
  }

  public List<SessionFactory> getCustomSessionFactories() {
    return this.customSessionFactories;
  }

  public ProcessEngineConfigurationImpl setCustomSessionFactories(List<SessionFactory> customSessionFactories) {
    this.customSessionFactories = customSessionFactories;
    return this;
  }

  public List<JobHandler> getCustomJobHandlers() {
    return this.customJobHandlers;
  }

  public ProcessEngineConfigurationImpl setCustomJobHandlers(List<JobHandler> customJobHandlers) {
    this.customJobHandlers = customJobHandlers;
    return this;
  }

  public List<String> getCustomScriptingEngineClasses() {
    return this.customScriptingEngineClasses;
  }

  public ProcessEngineConfigurationImpl setCustomScriptingEngineClasses(List<String> customScriptingEngineClasses) {
    this.customScriptingEngineClasses = customScriptingEngineClasses;
    return this;
  }

  public List<VariableType> getCustomPreVariableTypes() {
    return this.customPreVariableTypes;
  }

  public ProcessEngineConfigurationImpl setCustomPreVariableTypes(List<VariableType> customPreVariableTypes) {
    this.customPreVariableTypes = customPreVariableTypes;
    return this;
  }

  public List<VariableType> getCustomPostVariableTypes() {
    return this.customPostVariableTypes;
  }

  public ProcessEngineConfigurationImpl setCustomPostVariableTypes(List<VariableType> customPostVariableTypes) {
    this.customPostVariableTypes = customPostVariableTypes;
    return this;
  }

  public List<BpmnParseHandler> getPreBpmnParseHandlers() {
    return this.preBpmnParseHandlers;
  }

  public ProcessEngineConfigurationImpl setPreBpmnParseHandlers(List<BpmnParseHandler> preBpmnParseHandlers) {
    this.preBpmnParseHandlers = preBpmnParseHandlers;
    return this;
  }

  public List<BpmnParseHandler> getCustomDefaultBpmnParseHandlers() {
    return this.customDefaultBpmnParseHandlers;
  }

  public ProcessEngineConfigurationImpl setCustomDefaultBpmnParseHandlers(List<BpmnParseHandler> customDefaultBpmnParseHandlers) {
    this.customDefaultBpmnParseHandlers = customDefaultBpmnParseHandlers;
    return this;
  }

  public List<BpmnParseHandler> getPostBpmnParseHandlers() {
    return this.postBpmnParseHandlers;
  }

  public ProcessEngineConfigurationImpl setPostBpmnParseHandlers(List<BpmnParseHandler> postBpmnParseHandlers) {
    this.postBpmnParseHandlers = postBpmnParseHandlers;
    return this;
  }

  public ActivityBehaviorFactory getActivityBehaviorFactory() {
    return this.activityBehaviorFactory;
  }

  public ProcessEngineConfigurationImpl setActivityBehaviorFactory(ActivityBehaviorFactory activityBehaviorFactory) {
    this.activityBehaviorFactory = activityBehaviorFactory;
    return this;
  }

  public ListenerFactory getListenerFactory() {
    return this.listenerFactory;
  }

  public ProcessEngineConfigurationImpl setListenerFactory(ListenerFactory listenerFactory) {
    this.listenerFactory = listenerFactory;
    return this;
  }

  public BpmnParseFactory getBpmnParseFactory() {
    return this.bpmnParseFactory;
  }

  public ProcessEngineConfigurationImpl setBpmnParseFactory(BpmnParseFactory bpmnParseFactory) {
    this.bpmnParseFactory = bpmnParseFactory;
    return this;
  }

  public Map<Object, Object> getBeans() {
    return this.beans;
  }

  public ProcessEngineConfigurationImpl setBeans(Map<Object, Object> beans) {
    this.beans = beans;
    return this;
  }

  public List<ResolverFactory> getResolverFactories() {
    return this.resolverFactories;
  }

  public ProcessEngineConfigurationImpl setResolverFactories(List<ResolverFactory> resolverFactories) {
    this.resolverFactories = resolverFactories;
    return this;
  }

  public DeploymentManager getDeploymentManager() {
    return this.deploymentManager;
  }

  public ProcessEngineConfigurationImpl setDeploymentManager(DeploymentManager deploymentManager) {
    this.deploymentManager = deploymentManager;
    return this;
  }

  public ProcessEngineConfigurationImpl setDelegateInterceptor(DelegateInterceptor delegateInterceptor) {
    this.delegateInterceptor = delegateInterceptor;
    return this;
  }

  public DelegateInterceptor getDelegateInterceptor() {
    return this.delegateInterceptor;
  }

  public EventHandler getEventHandler(String eventType) {
    return (EventHandler)this.eventHandlers.get(eventType);
  }

  public ProcessEngineConfigurationImpl setEventHandlers(Map<String, EventHandler> eventHandlers) {
    this.eventHandlers = eventHandlers;
    return this;
  }

  public Map<String, EventHandler> getEventHandlers() {
    return this.eventHandlers;
  }

  public List<EventHandler> getCustomEventHandlers() {
    return this.customEventHandlers;
  }

  public ProcessEngineConfigurationImpl setCustomEventHandlers(List<EventHandler> customEventHandlers) {
    this.customEventHandlers = customEventHandlers;
    return this;
  }

  public FailedJobCommandFactory getFailedJobCommandFactory() {
    return this.failedJobCommandFactory;
  }

  public ProcessEngineConfigurationImpl setFailedJobCommandFactory(FailedJobCommandFactory failedJobCommandFactory) {
    this.failedJobCommandFactory = failedJobCommandFactory;
    return this;
  }

  public DataSource getIdGeneratorDataSource() {
    return this.idGeneratorDataSource;
  }

  public ProcessEngineConfigurationImpl setIdGeneratorDataSource(DataSource idGeneratorDataSource) {
    this.idGeneratorDataSource = idGeneratorDataSource;
    return this;
  }

  public String getIdGeneratorDataSourceJndiName() {
    return this.idGeneratorDataSourceJndiName;
  }

  public ProcessEngineConfigurationImpl setIdGeneratorDataSourceJndiName(String idGeneratorDataSourceJndiName) {
    this.idGeneratorDataSourceJndiName = idGeneratorDataSourceJndiName;
    return this;
  }

  public int getBatchSizeProcessInstances() {
    return this.batchSizeProcessInstances;
  }

  public ProcessEngineConfigurationImpl setBatchSizeProcessInstances(int batchSizeProcessInstances) {
    this.batchSizeProcessInstances = batchSizeProcessInstances;
    return this;
  }

  public int getBatchSizeTasks() {
    return this.batchSizeTasks;
  }

  public ProcessEngineConfigurationImpl setBatchSizeTasks(int batchSizeTasks) {
    this.batchSizeTasks = batchSizeTasks;
    return this;
  }

  public int getProcessDefinitionCacheLimit() {
    return this.processDefinitionCacheLimit;
  }

  public ProcessEngineConfigurationImpl setProcessDefinitionCacheLimit(int processDefinitionCacheLimit) {
    this.processDefinitionCacheLimit = processDefinitionCacheLimit;
    return this;
  }

  public DeploymentCache<ProcessDefinitionCacheEntry> getProcessDefinitionCache() {
    return this.processDefinitionCache;
  }

  public ProcessEngineConfigurationImpl setProcessDefinitionCache(DeploymentCache<ProcessDefinitionCacheEntry> processDefinitionCache) {
    this.processDefinitionCache = processDefinitionCache;
    return this;
  }

  public int getKnowledgeBaseCacheLimit() {
    return this.knowledgeBaseCacheLimit;
  }

  public ProcessEngineConfigurationImpl setKnowledgeBaseCacheLimit(int knowledgeBaseCacheLimit) {
    this.knowledgeBaseCacheLimit = knowledgeBaseCacheLimit;
    return this;
  }

  public DeploymentCache<Object> getKnowledgeBaseCache() {
    return this.knowledgeBaseCache;
  }

  public ProcessEngineConfigurationImpl setKnowledgeBaseCache(DeploymentCache<Object> knowledgeBaseCache) {
    this.knowledgeBaseCache = knowledgeBaseCache;
    return this;
  }

  public boolean isEnableSafeBpmnXml() {
    return this.enableSafeBpmnXml;
  }

  public ProcessEngineConfigurationImpl setEnableSafeBpmnXml(boolean enableSafeBpmnXml) {
    this.enableSafeBpmnXml = enableSafeBpmnXml;
    return this;
  }

  public ActivitiEventDispatcher getEventDispatcher() {
    return this.eventDispatcher;
  }

  public ProcessEngineConfigurationImpl setEventDispatcher(ActivitiEventDispatcher eventDispatcher) {
    this.eventDispatcher = eventDispatcher;
    return this;
  }

  public ProcessEngineConfigurationImpl setEnableEventDispatcher(boolean enableEventDispatcher) {
    this.enableEventDispatcher = enableEventDispatcher;
    return this;
  }

  public Map<String, List<ActivitiEventListener>> getTypedEventListeners() {
    return this.typedEventListeners;
  }

  public ProcessEngineConfigurationImpl setTypedEventListeners(Map<String, List<ActivitiEventListener>> typedListeners) {
    this.typedEventListeners = typedListeners;
    return this;
  }

  public List<ActivitiEventListener> getEventListeners() {
    return this.eventListeners;
  }

  public ProcessEngineConfigurationImpl setEventListeners(List<ActivitiEventListener> eventListeners) {
    this.eventListeners = eventListeners;
    return this;
  }

  public ProcessValidator getProcessValidator() {
    return this.processValidator;
  }

  public ProcessEngineConfigurationImpl setProcessValidator(ProcessValidator processValidator) {
    this.processValidator = processValidator;
    return this;
  }

  public boolean isEnableEventDispatcher() {
    return this.enableEventDispatcher;
  }

  public boolean isEnableDatabaseEventLogging() {
    return this.enableDatabaseEventLogging;
  }

  public ProcessEngineConfigurationImpl setEnableDatabaseEventLogging(boolean enableDatabaseEventLogging) {
    this.enableDatabaseEventLogging = enableDatabaseEventLogging;
    return this;
  }

  public int getMaxLengthStringVariableType() {
    return this.maxLengthStringVariableType;
  }

  public ProcessEngineConfigurationImpl setMaxLengthStringVariableType(int maxLengthStringVariableType) {
    this.maxLengthStringVariableType = maxLengthStringVariableType;
    return this;
  }

  public boolean isBulkInsertEnabled() {
    return this.isBulkInsertEnabled;
  }

  public ProcessEngineConfigurationImpl setBulkInsertEnabled(boolean isBulkInsertEnabled) {
    this.isBulkInsertEnabled = isBulkInsertEnabled;
    return this;
  }

  public int getMaxNrOfStatementsInBulkInsert() {
    return this.maxNrOfStatementsInBulkInsert;
  }

  public ProcessEngineConfigurationImpl setMaxNrOfStatementsInBulkInsert(int maxNrOfStatementsInBulkInsert) {
    this.maxNrOfStatementsInBulkInsert = maxNrOfStatementsInBulkInsert;
    return this;
  }

  public boolean isUsingRelationalDatabase() {
    return this.usingRelationalDatabase;
  }

  public ProcessEngineConfigurationImpl setUsingRelationalDatabase(boolean usingRelationalDatabase) {
    this.usingRelationalDatabase = usingRelationalDatabase;
    return this;
  }

  public boolean isEnableVerboseExecutionTreeLogging() {
    return this.enableVerboseExecutionTreeLogging;
  }

  public ProcessEngineConfigurationImpl setEnableVerboseExecutionTreeLogging(boolean enableVerboseExecutionTreeLogging) {
    this.enableVerboseExecutionTreeLogging = enableVerboseExecutionTreeLogging;
    return this;
  }

  public ProcessEngineConfigurationImpl setEnableEagerExecutionTreeFetching(boolean enableEagerExecutionTreeFetching) {
    this.performanceSettings.setEnableEagerExecutionTreeFetching(enableEagerExecutionTreeFetching);
    return this;
  }

  public ProcessEngineConfigurationImpl setEnableExecutionRelationshipCounts(boolean enableExecutionRelationshipCounts) {
    this.performanceSettings.setEnableExecutionRelationshipCounts(enableExecutionRelationshipCounts);
    return this;
  }

  public PerformanceSettings getPerformanceSettings() {
    return this.performanceSettings;
  }

  public void setPerformanceSettings(PerformanceSettings performanceSettings) {
    this.performanceSettings = performanceSettings;
  }

  public ProcessEngineConfigurationImpl setEnableLocalization(boolean enableLocalization) {
    this.performanceSettings.setEnableLocalization(enableLocalization);
    return this;
  }

  public AttachmentDataManager getAttachmentDataManager() {
    return this.attachmentDataManager;
  }

  public ProcessEngineConfigurationImpl setAttachmentDataManager(AttachmentDataManager attachmentDataManager) {
    this.attachmentDataManager = attachmentDataManager;
    return this;
  }

  public ByteArrayDataManager getByteArrayDataManager() {
    return this.byteArrayDataManager;
  }

  public ProcessEngineConfigurationImpl setByteArrayDataManager(ByteArrayDataManager byteArrayDataManager) {
    this.byteArrayDataManager = byteArrayDataManager;
    return this;
  }

  public CommentDataManager getCommentDataManager() {
    return this.commentDataManager;
  }

  public ProcessEngineConfigurationImpl setCommentDataManager(CommentDataManager commentDataManager) {
    this.commentDataManager = commentDataManager;
    return this;
  }

  public DeploymentDataManager getDeploymentDataManager() {
    return this.deploymentDataManager;
  }

  public ProcessEngineConfigurationImpl setDeploymentDataManager(DeploymentDataManager deploymentDataManager) {
    this.deploymentDataManager = deploymentDataManager;
    return this;
  }

  public EventLogEntryDataManager getEventLogEntryDataManager() {
    return this.eventLogEntryDataManager;
  }

  public ProcessEngineConfigurationImpl setEventLogEntryDataManager(EventLogEntryDataManager eventLogEntryDataManager) {
    this.eventLogEntryDataManager = eventLogEntryDataManager;
    return this;
  }

  public EventSubscriptionDataManager getEventSubscriptionDataManager() {
    return this.eventSubscriptionDataManager;
  }

  public ProcessEngineConfigurationImpl setEventSubscriptionDataManager(EventSubscriptionDataManager eventSubscriptionDataManager) {
    this.eventSubscriptionDataManager = eventSubscriptionDataManager;
    return this;
  }

  public ExecutionDataManager getExecutionDataManager() {
    return this.executionDataManager;
  }

  public ProcessEngineConfigurationImpl setExecutionDataManager(ExecutionDataManager executionDataManager) {
    this.executionDataManager = executionDataManager;
    return this;
  }

  public HistoricActivityInstanceDataManager getHistoricActivityInstanceDataManager() {
    return this.historicActivityInstanceDataManager;
  }

  public ProcessEngineConfigurationImpl setHistoricActivityInstanceDataManager(HistoricActivityInstanceDataManager historicActivityInstanceDataManager) {
    this.historicActivityInstanceDataManager = historicActivityInstanceDataManager;
    return this;
  }

  public HistoricDetailDataManager getHistoricDetailDataManager() {
    return this.historicDetailDataManager;
  }

  public ProcessEngineConfigurationImpl setHistoricDetailDataManager(HistoricDetailDataManager historicDetailDataManager) {
    this.historicDetailDataManager = historicDetailDataManager;
    return this;
  }

  public HistoricIdentityLinkDataManager getHistoricIdentityLinkDataManager() {
    return this.historicIdentityLinkDataManager;
  }

  public ProcessEngineConfigurationImpl setHistoricIdentityLinkDataManager(HistoricIdentityLinkDataManager historicIdentityLinkDataManager) {
    this.historicIdentityLinkDataManager = historicIdentityLinkDataManager;
    return this;
  }

  public HistoricProcessInstanceDataManager getHistoricProcessInstanceDataManager() {
    return this.historicProcessInstanceDataManager;
  }

  public ProcessEngineConfigurationImpl setHistoricProcessInstanceDataManager(HistoricProcessInstanceDataManager historicProcessInstanceDataManager) {
    this.historicProcessInstanceDataManager = historicProcessInstanceDataManager;
    return this;
  }

  public HistoricTaskInstanceDataManager getHistoricTaskInstanceDataManager() {
    return this.historicTaskInstanceDataManager;
  }

  public ProcessEngineConfigurationImpl setHistoricTaskInstanceDataManager(HistoricTaskInstanceDataManager historicTaskInstanceDataManager) {
    this.historicTaskInstanceDataManager = historicTaskInstanceDataManager;
    return this;
  }

  public HistoricVariableInstanceDataManager getHistoricVariableInstanceDataManager() {
    return this.historicVariableInstanceDataManager;
  }

  public ProcessEngineConfigurationImpl setHistoricVariableInstanceDataManager(HistoricVariableInstanceDataManager historicVariableInstanceDataManager) {
    this.historicVariableInstanceDataManager = historicVariableInstanceDataManager;
    return this;
  }

  public IdentityLinkDataManager getIdentityLinkDataManager() {
    return this.identityLinkDataManager;
  }

  public ProcessEngineConfigurationImpl setIdentityLinkDataManager(IdentityLinkDataManager identityLinkDataManager) {
    this.identityLinkDataManager = identityLinkDataManager;
    return this;
  }

  public JobDataManager getJobDataManager() {
    return this.jobDataManager;
  }

  public ProcessEngineConfigurationImpl setJobDataManager(JobDataManager jobDataManager) {
    this.jobDataManager = jobDataManager;
    return this;
  }

  public TimerJobDataManager getTimerJobDataManager() {
    return this.timerJobDataManager;
  }

  public ProcessEngineConfigurationImpl setTimerJobDataManager(TimerJobDataManager timerJobDataManager) {
    this.timerJobDataManager = timerJobDataManager;
    return this;
  }

  public SuspendedJobDataManager getSuspendedJobDataManager() {
    return this.suspendedJobDataManager;
  }

  public ProcessEngineConfigurationImpl setSuspendedJobDataManager(SuspendedJobDataManager suspendedJobDataManager) {
    this.suspendedJobDataManager = suspendedJobDataManager;
    return this;
  }

  public DeadLetterJobDataManager getDeadLetterJobDataManager() {
    return this.deadLetterJobDataManager;
  }

  public ProcessEngineConfigurationImpl setDeadLetterJobDataManager(DeadLetterJobDataManager deadLetterJobDataManager) {
    this.deadLetterJobDataManager = deadLetterJobDataManager;
    return this;
  }

  public ModelDataManager getModelDataManager() {
    return this.modelDataManager;
  }

  public ProcessEngineConfigurationImpl setModelDataManager(ModelDataManager modelDataManager) {
    this.modelDataManager = modelDataManager;
    return this;
  }

  public ProcessDefinitionDataManager getProcessDefinitionDataManager() {
    return this.processDefinitionDataManager;
  }

  public ProcessEngineConfigurationImpl setProcessDefinitionDataManager(ProcessDefinitionDataManager processDefinitionDataManager) {
    this.processDefinitionDataManager = processDefinitionDataManager;
    return this;
  }

  public ProcessDefinitionInfoDataManager getProcessDefinitionInfoDataManager() {
    return this.processDefinitionInfoDataManager;
  }

  public ProcessEngineConfigurationImpl setProcessDefinitionInfoDataManager(ProcessDefinitionInfoDataManager processDefinitionInfoDataManager) {
    this.processDefinitionInfoDataManager = processDefinitionInfoDataManager;
    return this;
  }

  public PropertyDataManager getPropertyDataManager() {
    return this.propertyDataManager;
  }

  public ProcessEngineConfigurationImpl setPropertyDataManager(PropertyDataManager propertyDataManager) {
    this.propertyDataManager = propertyDataManager;
    return this;
  }

  public ResourceDataManager getResourceDataManager() {
    return this.resourceDataManager;
  }

  public ProcessEngineConfigurationImpl setResourceDataManager(ResourceDataManager resourceDataManager) {
    this.resourceDataManager = resourceDataManager;
    return this;
  }

  public TaskDataManager getTaskDataManager() {
    return this.taskDataManager;
  }

  public ProcessEngineConfigurationImpl setTaskDataManager(TaskDataManager taskDataManager) {
    this.taskDataManager = taskDataManager;
    return this;
  }

  public VariableInstanceDataManager getVariableInstanceDataManager() {
    return this.variableInstanceDataManager;
  }

  public ProcessEngineConfigurationImpl setVariableInstanceDataManager(VariableInstanceDataManager variableInstanceDataManager) {
    this.variableInstanceDataManager = variableInstanceDataManager;
    return this;
  }

  public boolean isEnableConfiguratorServiceLoader() {
    return this.enableConfiguratorServiceLoader;
  }

  public AttachmentEntityManager getAttachmentEntityManager() {
    return this.attachmentEntityManager;
  }

  public ProcessEngineConfigurationImpl setAttachmentEntityManager(AttachmentEntityManager attachmentEntityManager) {
    this.attachmentEntityManager = attachmentEntityManager;
    return this;
  }

  public ByteArrayEntityManager getByteArrayEntityManager() {
    return this.byteArrayEntityManager;
  }

  public ProcessEngineConfigurationImpl setByteArrayEntityManager(ByteArrayEntityManager byteArrayEntityManager) {
    this.byteArrayEntityManager = byteArrayEntityManager;
    return this;
  }

  public CommentEntityManager getCommentEntityManager() {
    return this.commentEntityManager;
  }

  public ProcessEngineConfigurationImpl setCommentEntityManager(CommentEntityManager commentEntityManager) {
    this.commentEntityManager = commentEntityManager;
    return this;
  }

  public DeploymentEntityManager getDeploymentEntityManager() {
    return this.deploymentEntityManager;
  }

  public ProcessEngineConfigurationImpl setDeploymentEntityManager(DeploymentEntityManager deploymentEntityManager) {
    this.deploymentEntityManager = deploymentEntityManager;
    return this;
  }

  public EventLogEntryEntityManager getEventLogEntryEntityManager() {
    return this.eventLogEntryEntityManager;
  }

  public ProcessEngineConfigurationImpl setEventLogEntryEntityManager(EventLogEntryEntityManager eventLogEntryEntityManager) {
    this.eventLogEntryEntityManager = eventLogEntryEntityManager;
    return this;
  }

  public EventSubscriptionEntityManager getEventSubscriptionEntityManager() {
    return this.eventSubscriptionEntityManager;
  }

  public ProcessEngineConfigurationImpl setEventSubscriptionEntityManager(EventSubscriptionEntityManager eventSubscriptionEntityManager) {
    this.eventSubscriptionEntityManager = eventSubscriptionEntityManager;
    return this;
  }

  public ExecutionEntityManager getExecutionEntityManager() {
    return this.executionEntityManager;
  }

  public ProcessEngineConfigurationImpl setExecutionEntityManager(ExecutionEntityManager executionEntityManager) {
    this.executionEntityManager = executionEntityManager;
    return this;
  }

  public HistoricActivityInstanceEntityManager getHistoricActivityInstanceEntityManager() {
    return this.historicActivityInstanceEntityManager;
  }

  public ProcessEngineConfigurationImpl setHistoricActivityInstanceEntityManager(HistoricActivityInstanceEntityManager historicActivityInstanceEntityManager) {
    this.historicActivityInstanceEntityManager = historicActivityInstanceEntityManager;
    return this;
  }

  public HistoricDetailEntityManager getHistoricDetailEntityManager() {
    return this.historicDetailEntityManager;
  }

  public ProcessEngineConfigurationImpl setHistoricDetailEntityManager(HistoricDetailEntityManager historicDetailEntityManager) {
    this.historicDetailEntityManager = historicDetailEntityManager;
    return this;
  }

  public HistoricIdentityLinkEntityManager getHistoricIdentityLinkEntityManager() {
    return this.historicIdentityLinkEntityManager;
  }

  public ProcessEngineConfigurationImpl setHistoricIdentityLinkEntityManager(HistoricIdentityLinkEntityManager historicIdentityLinkEntityManager) {
    this.historicIdentityLinkEntityManager = historicIdentityLinkEntityManager;
    return this;
  }

  public HistoricProcessInstanceEntityManager getHistoricProcessInstanceEntityManager() {
    return this.historicProcessInstanceEntityManager;
  }

  public ProcessEngineConfigurationImpl setHistoricProcessInstanceEntityManager(HistoricProcessInstanceEntityManager historicProcessInstanceEntityManager) {
    this.historicProcessInstanceEntityManager = historicProcessInstanceEntityManager;
    return this;
  }

  public HistoricTaskInstanceEntityManager getHistoricTaskInstanceEntityManager() {
    return this.historicTaskInstanceEntityManager;
  }

  public ProcessEngineConfigurationImpl setHistoricTaskInstanceEntityManager(HistoricTaskInstanceEntityManager historicTaskInstanceEntityManager) {
    this.historicTaskInstanceEntityManager = historicTaskInstanceEntityManager;
    return this;
  }

  public HistoricVariableInstanceEntityManager getHistoricVariableInstanceEntityManager() {
    return this.historicVariableInstanceEntityManager;
  }

  public ProcessEngineConfigurationImpl setHistoricVariableInstanceEntityManager(HistoricVariableInstanceEntityManager historicVariableInstanceEntityManager) {
    this.historicVariableInstanceEntityManager = historicVariableInstanceEntityManager;
    return this;
  }

  public IdentityLinkEntityManager getIdentityLinkEntityManager() {
    return this.identityLinkEntityManager;
  }

  public ProcessEngineConfigurationImpl setIdentityLinkEntityManager(IdentityLinkEntityManager identityLinkEntityManager) {
    this.identityLinkEntityManager = identityLinkEntityManager;
    return this;
  }

  public JobEntityManager getJobEntityManager() {
    return this.jobEntityManager;
  }

  public ProcessEngineConfigurationImpl setJobEntityManager(JobEntityManager jobEntityManager) {
    this.jobEntityManager = jobEntityManager;
    return this;
  }

  public TimerJobEntityManager getTimerJobEntityManager() {
    return this.timerJobEntityManager;
  }

  public ProcessEngineConfigurationImpl setTimerJobEntityManager(TimerJobEntityManager timerJobEntityManager) {
    this.timerJobEntityManager = timerJobEntityManager;
    return this;
  }

  public SuspendedJobEntityManager getSuspendedJobEntityManager() {
    return this.suspendedJobEntityManager;
  }

  public ProcessEngineConfigurationImpl setSuspendedJobEntityManager(SuspendedJobEntityManager suspendedJobEntityManager) {
    this.suspendedJobEntityManager = suspendedJobEntityManager;
    return this;
  }

  public DeadLetterJobEntityManager getDeadLetterJobEntityManager() {
    return this.deadLetterJobEntityManager;
  }

  public ProcessEngineConfigurationImpl setDeadLetterJobEntityManager(DeadLetterJobEntityManager deadLetterJobEntityManager) {
    this.deadLetterJobEntityManager = deadLetterJobEntityManager;
    return this;
  }

  public ModelEntityManager getModelEntityManager() {
    return this.modelEntityManager;
  }

  public ProcessEngineConfigurationImpl setModelEntityManager(ModelEntityManager modelEntityManager) {
    this.modelEntityManager = modelEntityManager;
    return this;
  }

  public ProcessDefinitionEntityManager getProcessDefinitionEntityManager() {
    return this.processDefinitionEntityManager;
  }

  public ProcessEngineConfigurationImpl setProcessDefinitionEntityManager(ProcessDefinitionEntityManager processDefinitionEntityManager) {
    this.processDefinitionEntityManager = processDefinitionEntityManager;
    return this;
  }

  public ProcessDefinitionInfoEntityManager getProcessDefinitionInfoEntityManager() {
    return this.processDefinitionInfoEntityManager;
  }

  public ProcessEngineConfigurationImpl setProcessDefinitionInfoEntityManager(ProcessDefinitionInfoEntityManager processDefinitionInfoEntityManager) {
    this.processDefinitionInfoEntityManager = processDefinitionInfoEntityManager;
    return this;
  }

  public PropertyEntityManager getPropertyEntityManager() {
    return this.propertyEntityManager;
  }

  public ProcessEngineConfigurationImpl setPropertyEntityManager(PropertyEntityManager propertyEntityManager) {
    this.propertyEntityManager = propertyEntityManager;
    return this;
  }

  public ResourceEntityManager getResourceEntityManager() {
    return this.resourceEntityManager;
  }

  public ProcessEngineConfigurationImpl setResourceEntityManager(ResourceEntityManager resourceEntityManager) {
    this.resourceEntityManager = resourceEntityManager;
    return this;
  }

  public TaskEntityManager getTaskEntityManager() {
    return this.taskEntityManager;
  }

  public ProcessEngineConfigurationImpl setTaskEntityManager(TaskEntityManager taskEntityManager) {
    this.taskEntityManager = taskEntityManager;
    return this;
  }

  public VariableInstanceEntityManager getVariableInstanceEntityManager() {
    return this.variableInstanceEntityManager;
  }

  public ProcessEngineConfigurationImpl setVariableInstanceEntityManager(VariableInstanceEntityManager variableInstanceEntityManager) {
    this.variableInstanceEntityManager = variableInstanceEntityManager;
    return this;
  }

  public TableDataManager getTableDataManager() {
    return this.tableDataManager;
  }

  public ProcessEngineConfigurationImpl setTableDataManager(TableDataManager tableDataManager) {
    this.tableDataManager = tableDataManager;
    return this;
  }

  public HistoryManager getHistoryManager() {
    return this.historyManager;
  }

  public ProcessEngineConfigurationImpl setHistoryManager(HistoryManager historyManager) {
    this.historyManager = historyManager;
    return this;
  }

  public JobManager getJobManager() {
    return this.jobManager;
  }

  public ProcessEngineConfigurationImpl setJobManager(JobManager jobManager) {
    this.jobManager = jobManager;
    return this;
  }

  public ProcessEngineConfigurationImpl setClock(Clock clock) {
    if (this.clock == null) {
      this.clock = clock;
    } else {
      this.clock.setCurrentCalendar(clock.getCurrentCalendar());
    }

    return this;
  }

  public void resetClock() {
    if (this.clock != null) {
      this.clock.reset();
    }

  }

  public DelegateExpressionFieldInjectionMode getDelegateExpressionFieldInjectionMode() {
    return this.delegateExpressionFieldInjectionMode;
  }

  public ProcessEngineConfigurationImpl setDelegateExpressionFieldInjectionMode(DelegateExpressionFieldInjectionMode delegateExpressionFieldInjectionMode) {
    this.delegateExpressionFieldInjectionMode = delegateExpressionFieldInjectionMode;
    return this;
  }

  public ObjectMapper getObjectMapper() {
    return this.objectMapper;
  }

  public ProcessEngineConfigurationImpl setObjectMapper(ObjectMapper objectMapper) {
    this.objectMapper = objectMapper;
    return this;
  }

  public int getAsyncExecutorCorePoolSize() {
    return this.asyncExecutorCorePoolSize;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorCorePoolSize(int asyncExecutorCorePoolSize) {
    this.asyncExecutorCorePoolSize = asyncExecutorCorePoolSize;
    return this;
  }

  public int getAsyncExecutorNumberOfRetries() {
    return this.asyncExecutorNumberOfRetries;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorNumberOfRetries(int asyncExecutorNumberOfRetries) {
    this.asyncExecutorNumberOfRetries = asyncExecutorNumberOfRetries;
    return this;
  }

  public int getAsyncExecutorMaxPoolSize() {
    return this.asyncExecutorMaxPoolSize;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorMaxPoolSize(int asyncExecutorMaxPoolSize) {
    this.asyncExecutorMaxPoolSize = asyncExecutorMaxPoolSize;
    return this;
  }

  public long getAsyncExecutorThreadKeepAliveTime() {
    return this.asyncExecutorThreadKeepAliveTime;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorThreadKeepAliveTime(long asyncExecutorThreadKeepAliveTime) {
    this.asyncExecutorThreadKeepAliveTime = asyncExecutorThreadKeepAliveTime;
    return this;
  }

  public int getAsyncExecutorThreadPoolQueueSize() {
    return this.asyncExecutorThreadPoolQueueSize;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorThreadPoolQueueSize(int asyncExecutorThreadPoolQueueSize) {
    this.asyncExecutorThreadPoolQueueSize = asyncExecutorThreadPoolQueueSize;
    return this;
  }

  public BlockingQueue<Runnable> getAsyncExecutorThreadPoolQueue() {
    return this.asyncExecutorThreadPoolQueue;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorThreadPoolQueue(BlockingQueue<Runnable> asyncExecutorThreadPoolQueue) {
    this.asyncExecutorThreadPoolQueue = asyncExecutorThreadPoolQueue;
    return this;
  }

  public long getAsyncExecutorSecondsToWaitOnShutdown() {
    return this.asyncExecutorSecondsToWaitOnShutdown;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorSecondsToWaitOnShutdown(long asyncExecutorSecondsToWaitOnShutdown) {
    this.asyncExecutorSecondsToWaitOnShutdown = asyncExecutorSecondsToWaitOnShutdown;
    return this;
  }

  public int getAsyncExecutorMaxTimerJobsPerAcquisition() {
    return this.asyncExecutorMaxTimerJobsPerAcquisition;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorMaxTimerJobsPerAcquisition(int asyncExecutorMaxTimerJobsPerAcquisition) {
    this.asyncExecutorMaxTimerJobsPerAcquisition = asyncExecutorMaxTimerJobsPerAcquisition;
    return this;
  }

  public int getAsyncExecutorMaxAsyncJobsDuePerAcquisition() {
    return this.asyncExecutorMaxAsyncJobsDuePerAcquisition;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorMaxAsyncJobsDuePerAcquisition(int asyncExecutorMaxAsyncJobsDuePerAcquisition) {
    this.asyncExecutorMaxAsyncJobsDuePerAcquisition = asyncExecutorMaxAsyncJobsDuePerAcquisition;
    return this;
  }

  public int getAsyncExecutorDefaultTimerJobAcquireWaitTime() {
    return this.asyncExecutorDefaultTimerJobAcquireWaitTime;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorDefaultTimerJobAcquireWaitTime(int asyncExecutorDefaultTimerJobAcquireWaitTime) {
    this.asyncExecutorDefaultTimerJobAcquireWaitTime = asyncExecutorDefaultTimerJobAcquireWaitTime;
    return this;
  }

  public int getAsyncExecutorDefaultAsyncJobAcquireWaitTime() {
    return this.asyncExecutorDefaultAsyncJobAcquireWaitTime;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorDefaultAsyncJobAcquireWaitTime(int asyncExecutorDefaultAsyncJobAcquireWaitTime) {
    this.asyncExecutorDefaultAsyncJobAcquireWaitTime = asyncExecutorDefaultAsyncJobAcquireWaitTime;
    return this;
  }

  public int getAsyncExecutorDefaultQueueSizeFullWaitTime() {
    return this.asyncExecutorDefaultQueueSizeFullWaitTime;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorDefaultQueueSizeFullWaitTime(int asyncExecutorDefaultQueueSizeFullWaitTime) {
    this.asyncExecutorDefaultQueueSizeFullWaitTime = asyncExecutorDefaultQueueSizeFullWaitTime;
    return this;
  }

  public String getAsyncExecutorLockOwner() {
    return this.asyncExecutorLockOwner;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorLockOwner(String asyncExecutorLockOwner) {
    this.asyncExecutorLockOwner = asyncExecutorLockOwner;
    return this;
  }

  public int getAsyncExecutorTimerLockTimeInMillis() {
    return this.asyncExecutorTimerLockTimeInMillis;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorTimerLockTimeInMillis(int asyncExecutorTimerLockTimeInMillis) {
    this.asyncExecutorTimerLockTimeInMillis = asyncExecutorTimerLockTimeInMillis;
    return this;
  }

  public int getAsyncExecutorAsyncJobLockTimeInMillis() {
    return this.asyncExecutorAsyncJobLockTimeInMillis;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorAsyncJobLockTimeInMillis(int asyncExecutorAsyncJobLockTimeInMillis) {
    this.asyncExecutorAsyncJobLockTimeInMillis = asyncExecutorAsyncJobLockTimeInMillis;
    return this;
  }

  public int getAsyncExecutorResetExpiredJobsInterval() {
    return this.asyncExecutorResetExpiredJobsInterval;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorResetExpiredJobsInterval(int asyncExecutorResetExpiredJobsInterval) {
    this.asyncExecutorResetExpiredJobsInterval = asyncExecutorResetExpiredJobsInterval;
    return this;
  }

  public ExecuteAsyncRunnableFactory getAsyncExecutorExecuteAsyncRunnableFactory() {
    return this.asyncExecutorExecuteAsyncRunnableFactory;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorExecuteAsyncRunnableFactory(ExecuteAsyncRunnableFactory asyncExecutorExecuteAsyncRunnableFactory) {
    this.asyncExecutorExecuteAsyncRunnableFactory = asyncExecutorExecuteAsyncRunnableFactory;
    return this;
  }

  public int getAsyncExecutorResetExpiredJobsPageSize() {
    return this.asyncExecutorResetExpiredJobsPageSize;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorResetExpiredJobsPageSize(int asyncExecutorResetExpiredJobsPageSize) {
    this.asyncExecutorResetExpiredJobsPageSize = asyncExecutorResetExpiredJobsPageSize;
    return this;
  }

  public boolean isAsyncExecutorIsMessageQueueMode() {
    return this.asyncExecutorMessageQueueMode;
  }

  public ProcessEngineConfigurationImpl setAsyncExecutorMessageQueueMode(boolean asyncExecutorMessageQueueMode) {
    this.asyncExecutorMessageQueueMode = asyncExecutorMessageQueueMode;
    return this;
  }

  public EventSubscriptionPayloadMappingProvider getEventSubscriptionPayloadMappingProvider() {
    return this.eventSubscriptionPayloadMappingProvider;
  }

  public void setEventSubscriptionPayloadMappingProvider(EventSubscriptionPayloadMappingProvider eventSubscriptionPayloadMappingProvider) {
    this.eventSubscriptionPayloadMappingProvider = eventSubscriptionPayloadMappingProvider;
  }
}
